You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by rm...@apache.org on 2011/08/16 00:03:52 UTC
svn commit: r1158029 [4/15] - in /lucene/dev/branches/fieldtype_conflicted:
lucene/ lucene/contrib/ lucene/contrib/demo/src/java/org/apache/lucene/demo/
lucene/contrib/highlighter/src/java/org/apache/lucene/search/highlight/
lucene/contrib/highlighter/...
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/Field.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/Field.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/Field.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/Field.java Mon Aug 15 22:03:41 2011
@@ -20,335 +20,224 @@ package org.apache.lucene.document;
import java.io.Reader;
import org.apache.lucene.analysis.TokenStream;
+<<<<<<<
import org.apache.lucene.index.FieldInfo.IndexOptions;
import org.apache.lucene.index.IndexWriter;
+=======
+import org.apache.lucene.document.NumericField;
+import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.StringHelper;
+>>>>>>>
/**
- A field is a section of a Document. Each field has two parts, a name and a
- value. Values may be free text, provided as a String or as a Reader, or they
- may be atomic keywords, which are not further processed. Such keywords may
- be used to represent dates, urls, etc. Fields are optionally stored in the
- index, so that they may be returned with hits on the document.
- */
-
-public final class Field extends AbstractField implements Fieldable {
-
- /** Specifies whether and how a field should be stored. */
- public static enum Store {
-
- /** Store the original field value in the index. This is useful for short texts
- * like a document's title which should be displayed with the results. The
- * value is stored in its original form, i.e. no analyzer is used before it is
- * stored.
- */
- YES {
- @Override
- public boolean isStored() { return true; }
- },
-
- /** Do not store the field value in the index. */
- NO {
- @Override
- public boolean isStored() { return false; }
- };
-
- public abstract boolean isStored();
- }
-
- /** Specifies whether and how a field should be indexed. */
- public static enum Index {
-
- /** Do not index the field value. This field can thus not be searched,
- * but one can still access its contents provided it is
- * {@link Field.Store stored}. */
- NO {
- @Override
- public boolean isIndexed() { return false; }
- @Override
- public boolean isAnalyzed() { return false; }
- @Override
- public boolean omitNorms() { return true; }
- },
-
- /** Index the tokens produced by running the field's
- * value through an Analyzer. This is useful for
- * common text. */
- ANALYZED {
- @Override
- public boolean isIndexed() { return true; }
- @Override
- public boolean isAnalyzed() { return true; }
- @Override
- public boolean omitNorms() { return false; }
- },
-
- /** Index the field's value without using an Analyzer, so it can be searched.
- * As no analyzer is used the value will be stored as a single term. This is
- * useful for unique Ids like product numbers.
- */
- NOT_ANALYZED {
- @Override
- public boolean isIndexed() { return true; }
- @Override
- public boolean isAnalyzed() { return false; }
- @Override
- public boolean omitNorms() { return false; }
- },
-
- /** Expert: Index the field's value without an Analyzer,
- * and also disable the indexing of norms. Note that you
- * can also separately enable/disable norms by calling
- * {@link Field#setOmitNorms}. No norms means that
- * index-time field and document boosting and field
- * length normalization are disabled. The benefit is
- * less memory usage as norms take up one byte of RAM
- * per indexed field for every document in the index,
- * during searching. Note that once you index a given
- * field <i>with</i> norms disabled, enabling norms will
- * have no effect. In other words, for this to have the
- * above described effect on a field, one instance of
- * that field must be indexed with NOT_ANALYZED_NO_NORMS
- * at some point. */
- NOT_ANALYZED_NO_NORMS {
- @Override
- public boolean isIndexed() { return true; }
- @Override
- public boolean isAnalyzed() { return false; }
- @Override
- public boolean omitNorms() { return true; }
- },
-
- /** Expert: Index the tokens produced by running the
- * field's value through an Analyzer, and also
- * separately disable the storing of norms. See
- * {@link #NOT_ANALYZED_NO_NORMS} for what norms are
- * and why you may want to disable them. */
- ANALYZED_NO_NORMS {
- @Override
- public boolean isIndexed() { return true; }
- @Override
- public boolean isAnalyzed() { return true; }
- @Override
- public boolean omitNorms() { return true; }
- };
-
- /** Get the best representation of the index given the flags. */
- public static Index toIndex(boolean indexed, boolean analyzed) {
- return toIndex(indexed, analyzed, false);
- }
-
- /** Expert: Get the best representation of the index given the flags. */
- public static Index toIndex(boolean indexed, boolean analyzed, boolean omitNorms) {
-
- // If it is not indexed nothing else matters
- if (!indexed) {
- return Index.NO;
- }
+ * A field is a section of a Document. Each field has two parts, a name and a
+ * value. Values may be free text, provided as a String or as a Reader, or they
+ * may be atomic keywords, which are not further processed. Such keywords may be
+ * used to represent dates, urls, etc. Fields are optionally stored in the
+ * index, so that they may be returned with hits on the document.
+ */
- // typical, non-expert
- if (!omitNorms) {
- if (analyzed) {
- return Index.ANALYZED;
- }
- return Index.NOT_ANALYZED;
- }
+public class Field implements IndexableField {
+
+ protected FieldType type;
+ protected String name = "body";
+ // the data object for all different kind of field values
+ protected Object fieldsData = null;
+ // pre-analyzed tokenStream for indexed fields
+ protected TokenStream tokenStream;
+ protected boolean isBinary = false;
+ // length/offset for all primitive types
+ protected int binaryLength;
+ protected int binaryOffset;
+
+ protected float boost = 1.0f;
- // Expert: Norms omitted
- if (analyzed) {
- return Index.ANALYZED_NO_NORMS;
- }
- return Index.NOT_ANALYZED_NO_NORMS;
+ public Field(String name, FieldType type) {
+ this.name = name;
+ this.type = type;
+ }
+
+ public Field(String name, FieldType type, Reader reader) {
+ if (name == null)
+ throw new NullPointerException("name cannot be null");
+ if (reader == null)
+ throw new NullPointerException("reader cannot be null");
+
+ this.name = StringHelper.intern(name); // field names are interned
+ this.fieldsData = reader;
+ this.type = type;
+ }
+
+ public Field(String name, FieldType type, TokenStream tokenStream) {
+ if (name == null)
+ throw new NullPointerException("name cannot be null");
+ if (tokenStream == null)
+ throw new NullPointerException("tokenStream cannot be null");
+
+ this.name = StringHelper.intern(name); // field names are interned
+ this.fieldsData = null;
+ this.tokenStream = tokenStream;
+ this.type = type;
+ }
+
+ public Field(String name, FieldType type, byte[] value) {
+ this(name, type, value, 0, value.length);
+ }
+
+ public Field(String name, FieldType type, byte[] value, int offset, int length) {
+ this.isBinary = true;
+ this.fieldsData = value;
+ this.type = type;
+ this.binaryOffset = offset;
+ this.binaryLength = length;
+ this.name = StringHelper.intern(name);
+ }
+
+ public Field(String name, FieldType type, String value) {
+ this(name, true, type, value);
+ }
+
+ public Field(String name, boolean internName, FieldType type, String value) {
+ if (name == null) {
+ throw new IllegalArgumentException("name cannot be null");
}
-
- public abstract boolean isIndexed();
- public abstract boolean isAnalyzed();
- public abstract boolean omitNorms();
- }
-
- /** Specifies whether and how a field should have term vectors. */
- public static enum TermVector {
-
- /** Do not store term vectors.
- */
- NO {
- @Override
- public boolean isStored() { return false; }
- @Override
- public boolean withPositions() { return false; }
- @Override
- public boolean withOffsets() { return false; }
- },
-
- /** Store the term vectors of each document. A term vector is a list
- * of the document's terms and their number of occurrences in that document. */
- YES {
- @Override
- public boolean isStored() { return true; }
- @Override
- public boolean withPositions() { return false; }
- @Override
- public boolean withOffsets() { return false; }
- },
-
- /**
- * Store the term vector + token position information
- *
- * @see #YES
- */
- WITH_POSITIONS {
- @Override
- public boolean isStored() { return true; }
- @Override
- public boolean withPositions() { return true; }
- @Override
- public boolean withOffsets() { return false; }
- },
-
- /**
- * Store the term vector + Token offset information
- *
- * @see #YES
- */
- WITH_OFFSETS {
- @Override
- public boolean isStored() { return true; }
- @Override
- public boolean withPositions() { return false; }
- @Override
- public boolean withOffsets() { return true; }
- },
-
- /**
- * Store the term vector + Token position and offset information
- *
- * @see #YES
- * @see #WITH_POSITIONS
- * @see #WITH_OFFSETS
- */
- WITH_POSITIONS_OFFSETS {
- @Override
- public boolean isStored() { return true; }
- @Override
- public boolean withPositions() { return true; }
- @Override
- public boolean withOffsets() { return true; }
- };
-
- /** Get the best representation of a TermVector given the flags. */
- public static TermVector toTermVector(boolean stored, boolean withOffsets, boolean withPositions) {
-
- // If it is not stored, nothing else matters.
- if (!stored) {
- return TermVector.NO;
- }
-
- if (withOffsets) {
- if (withPositions) {
- return Field.TermVector.WITH_POSITIONS_OFFSETS;
- }
- return Field.TermVector.WITH_OFFSETS;
- }
-
- if (withPositions) {
- return Field.TermVector.WITH_POSITIONS;
- }
- return Field.TermVector.YES;
+ if (value == null) {
+ throw new IllegalArgumentException("value cannot be null");
+ }
+ if (!type.stored() && !type.indexed()) {
+ throw new IllegalArgumentException("it doesn't make sense to have a field that "
+ + "is neither indexed nor stored");
}
+ if (!type.indexed() && !type.tokenized() && (type.storeTermVectors())) {
+ throw new IllegalArgumentException("cannot store term vector information "
+ + "for a field that is not indexed");
+ }
+
+ this.type = type;
+ this.name = name;
+ this.fieldsData = value;
+
+ if (internName) // field names are optionally interned
+ name = StringHelper.intern(name);
+ }
- public abstract boolean isStored();
- public abstract boolean withPositions();
- public abstract boolean withOffsets();
+ public boolean isNumeric() {
+ return false;
}
+ /**
+ * The value of the field as a String, or null. If null, the Reader value or
+ * binary value is used. Exactly one of stringValue(), readerValue(), and
+ * getBinaryValue() must be set.
+ */
+ public String stringValue() {
+ return fieldsData instanceof String ? (String) fieldsData : null;
+ }
- /** The value of the field as a String, or null. If null, the Reader value or
- * binary value is used. Exactly one of stringValue(),
- * readerValue(), and getBinaryValue() must be set. */
- public String stringValue() { return fieldsData instanceof String ? (String)fieldsData : null; }
+ /**
+ * The value of the field as a Reader, or null. If null, the String value or
+ * binary value is used. Exactly one of stringValue(), readerValue(), and
+ * getBinaryValue() must be set.
+ */
+ public Reader readerValue() {
+ return fieldsData instanceof Reader ? (Reader) fieldsData : null;
+ }
- /** The value of the field as a Reader, or null. If null, the String value or
- * binary value is used. Exactly one of stringValue(),
- * readerValue(), and getBinaryValue() must be set. */
- public Reader readerValue() { return fieldsData instanceof Reader ? (Reader)fieldsData : null; }
-
- /** The TokesStream for this field to be used when indexing, or null. If null, the Reader value
- * or String value is analyzed to produce the indexed tokens. */
- public TokenStream tokenStreamValue() { return tokenStream; }
+ /**
+ * The TokesStream for this field to be used when indexing, or null. If null,
+ * the Reader value or String value is analyzed to produce the indexed tokens.
+ */
+ public TokenStream tokenStreamValue() {
+ return tokenStream;
+ }
-
- /** <p>Expert: change the value of this field. This can
- * be used during indexing to re-use a single Field
- * instance to improve indexing speed by avoiding GC cost
- * of new'ing and reclaiming Field instances. Typically
- * a single {@link Document} instance is re-used as
- * well. This helps most on small documents.</p>
+ /**
+ * <p>
+ * Expert: change the value of this field. This can be used during indexing to
+ * re-use a single Field instance to improve indexing speed by avoiding GC
+ * cost of new'ing and reclaiming Field instances. Typically a single
+ * {@link Document} instance is re-used as well. This helps most on small
+ * documents.
+ * </p>
*
- * <p>Each Field instance should only be used once
- * within a single {@link Document} instance. See <a
- * href="http://wiki.apache.org/lucene-java/ImproveIndexingSpeed">ImproveIndexingSpeed</a>
- * for details.</p> */
+ * <p>
+ * Each Field instance should only be used once within a single
+ * {@link Document} instance. See <a
+ * href="http://wiki.apache.org/lucene-java/ImproveIndexingSpeed"
+ * >ImproveIndexingSpeed</a> for details.
+ * </p>
+ */
public void setValue(String value) {
if (isBinary) {
- throw new IllegalArgumentException("cannot set a String value on a binary field");
+ throw new IllegalArgumentException(
+ "cannot set a String value on a binary field");
}
fieldsData = value;
}
-
- /** Expert: change the value of this field. See <a href="#setValue(java.lang.String)">setValue(String)</a>. */
+
+ /**
+ * Expert: change the value of this field. See <a
+ * href="#setValue(java.lang.String)">setValue(String)</a>.
+ */
public void setValue(Reader value) {
if (isBinary) {
- throw new IllegalArgumentException("cannot set a Reader value on a binary field");
+ throw new IllegalArgumentException(
+ "cannot set a Reader value on a binary field");
}
- if (isStored) {
- throw new IllegalArgumentException("cannot set a Reader value on a stored field");
+ if (stored()) {
+ throw new IllegalArgumentException(
+ "cannot set a Reader value on a stored field");
}
fieldsData = value;
}
-
- /** Expert: change the value of this field. See <a href="#setValue(java.lang.String)">setValue(String)</a>. */
+
+ /**
+ * Expert: change the value of this field. See <a
+ * href="#setValue(java.lang.String)">setValue(String)</a>.
+ */
public void setValue(byte[] value) {
if (!isBinary) {
- throw new IllegalArgumentException("cannot set a byte[] value on a non-binary field");
+ throw new IllegalArgumentException(
+ "cannot set a byte[] value on a non-binary field");
}
fieldsData = value;
binaryLength = value.length;
binaryOffset = 0;
}
-
- /** Expert: change the value of this field. See <a href="#setValue(java.lang.String)">setValue(String)</a>. */
+
+ /**
+ * Expert: change the value of this field. See <a
+ * href="#setValue(java.lang.String)">setValue(String)</a>.
+ */
public void setValue(byte[] value, int offset, int length) {
if (!isBinary) {
- throw new IllegalArgumentException("cannot set a byte[] value on a non-binary field");
+ throw new IllegalArgumentException(
+ "cannot set a byte[] value on a non-binary field");
}
fieldsData = value;
binaryLength = length;
binaryOffset = offset;
}
- /** Expert: sets the token stream to be used for indexing and causes isIndexed() and isTokenized() to return true.
- * May be combined with stored values from stringValue() or getBinaryValue() */
+ /**
+ * Expert: sets the token stream to be used for indexing and causes
+ * isIndexed() and isTokenized() to return true. May be combined with stored
+ * values from stringValue() or getBinaryValue()
+ */
public void setTokenStream(TokenStream tokenStream) {
- this.isIndexed = true;
- this.isTokenized = true;
+ if (!indexed() || !tokenized()) {
+ throw new IllegalArgumentException(
+ "cannot set token stream on non indexed and tokenized field");
+ }
this.tokenStream = tokenStream;
}
-
- /**
- * Create a field by specifying its name, value and how it will
- * be saved in the index. Term vectors will not be stored in the index.
- *
- * @param name The name of the field
- * @param value The string to process
- * @param store Whether <code>value</code> should be stored in the index
- * @param index Whether the field should be indexed, and if so, if it should
- * be tokenized before indexing
- * @throws NullPointerException if name or value is <code>null</code>
- * @throws IllegalArgumentException if the field is neither stored nor indexed
- */
- public Field(String name, String value, Store store, Index index) {
- this(name, value, store, index, TermVector.NO);
+
+ public String name() {
+ return name;
}
+<<<<<<<
/**
* Create a field by specifying its name, value and how it will
* be saved in the index.
@@ -404,15 +293,37 @@ public final class Field extends Abstrac
* not be stored. The Reader is read only when the Document is added to the index,
* i.e. you may not close the Reader until {@link IndexWriter#addDocument(Document)}
* has been called.
+=======
+ public float boost() {
+ return boost;
+ }
+
+ /**
+ * Sets the boost factor hits on this field. This value will be multiplied
+ * into the score of all hits on this this field of this document.
*
- * @param name The name of the field
- * @param reader The reader with the content
- * @throws NullPointerException if name or reader is <code>null</code>
+ * <p>
+ * Boost is used to compute the norm factor for the field. By default, in the
+ * {@link org.apache.lucene.search.Similarity#computeNorm(FieldInvertState)}
+ * method, the boost value is multiplied by the length normalization factor
+ * and then rounded by
+ * {@link org.apache.lucene.search.Similarity#encodeNormValue(float)} before
+ * it is stored in the index. One should attempt to ensure that this product
+ * does not overflow the range of that encoding.
+>>>>>>>
+ *
+ * @see org.apache.lucene.search.Similarity#computeNorm(FieldInvertState)
+ * @see org.apache.lucene.search.Similarity#encodeNormValue(float)
*/
- public Field(String name, Reader reader) {
- this(name, reader, TermVector.NO);
+ public void setBoost(float boost) {
+ this.boost = boost;
+ }
+
+ public boolean numeric() {
+ return false;
}
+<<<<<<<
/**
* Create a tokenized and indexed field that is not stored, optionally with
* storing term vectors. The Reader is read only when the Document is added to the index,
@@ -441,23 +352,17 @@ public final class Field extends Abstrac
this.isBinary = false;
setStoreTermVector(termVector);
+=======
+ public Number numericValue() {
+ return null;
+>>>>>>>
}
- /**
- * Create a tokenized and indexed field that is not stored. Term vectors will
- * not be stored. This is useful for pre-analyzed fields.
- * The TokenStream is read only when the Document is added to the index,
- * i.e. you may not close the TokenStream until {@link IndexWriter#addDocument(Document)}
- * has been called.
- *
- * @param name The name of the field
- * @param tokenStream The TokenStream with the content
- * @throws NullPointerException if name or tokenStream is <code>null</code>
- */
- public Field(String name, TokenStream tokenStream) {
- this(name, tokenStream, TermVector.NO);
+ public NumericField.DataType numericDataType() {
+ return null;
}
+<<<<<<<
/**
* Create a tokenized and indexed field that is not stored, optionally with
* storing term vectors. This is useful for pre-analyzed fields.
@@ -488,29 +393,109 @@ public final class Field extends Abstrac
this.isBinary = false;
setStoreTermVector(termVector);
+=======
+ private byte[] getBinaryValue(byte[] result /* unused */) {
+ if (isBinary || fieldsData instanceof byte[]) return (byte[]) fieldsData;
+ else return null;
+ }
+
+ private byte[] getBinaryValue() {
+ return getBinaryValue(null);
+ }
+
+ public BytesRef binaryValue(BytesRef reuse) {
+ final byte[] bytes = getBinaryValue();
+ if (bytes != null) {
+ if (reuse == null) {
+ return new BytesRef(bytes, getBinaryOffset(), getBinaryLength());
+ } else {
+ reuse.bytes = bytes;
+ reuse.offset = getBinaryOffset();
+ reuse.length = getBinaryLength();
+ return reuse;
+ }
+ } else {
+ return null;
+ }
+>>>>>>>
}
-
/**
- * Create a stored field with binary value. Optionally the value may be compressed.
+ * Returns length of byte[] segment that is used as value, if Field is not
+ * binary returned value is undefined
*
- * @param name The name of the field
- * @param value The binary value
+ * @return length of byte[] segment that represents this Field value
*/
- public Field(String name, byte[] value) {
- this(name, value, 0, value.length);
+ private int getBinaryLength() {
+ if (isBinary) {
+ return binaryLength;
+ } else if (fieldsData instanceof byte[]) return ((byte[]) fieldsData).length;
+ else return 0;
}
-
+
/**
- * Create a stored field with binary value. Optionally the value may be compressed.
+ * Returns offset into byte[] segment that is used as value, if Field is not
+ * binary returned value is undefined
*
- * @param name The name of the field
- * @param value The binary value
- * @param offset Starting offset in value where this Field's bytes are
- * @param length Number of bytes to use for this Field, starting at offset
+ * @return index of the first character in byte[] segment that represents this
+ * Field value
*/
- public Field(String name, byte[] value, int offset, int length) {
+ public int getBinaryOffset() {
+ return binaryOffset;
+ }
+
+ public boolean isBinary() {
+ return isBinary;
+ }
+
+ /** methods from inner FieldType */
+
+ public boolean stored() {
+ return type.stored();
+ }
+
+ public boolean indexed() {
+ return type.indexed();
+ }
+
+ public boolean tokenized() {
+ return type.tokenized();
+ }
+
+ public boolean omitNorms() {
+ return type.omitNorms();
+ }
+
+ public boolean omitTermFreqAndPositions() {
+ return type.omitTermFreqAndPositions();
+ }
+
+ public boolean storeTermVectors() {
+ return type.storeTermVectors();
+ }
+
+ public boolean storeTermVectorOffsets() {
+ return type.storeTermVectorOffsets();
+ }
+
+ public boolean storeTermVectorPositions() {
+ return type.storeTermVectorPositions();
+ }
+
+ public boolean lazy() {
+ return type.lazy();
+ }
+
+ /** Prints a Field for human consumption. */
+ @Override
+ public final String toString() {
+ StringBuilder result = new StringBuilder();
+ result.append(type.toString());
+ result.append('<');
+ result.append(name);
+ result.append(':');
+<<<<<<<
if (name == null)
throw new IllegalArgumentException("name cannot be null");
if (value == null)
@@ -530,5 +515,13 @@ public final class Field extends Abstrac
binaryOffset = offset;
setStoreTermVector(TermVector.NO);
+=======
+ if (fieldsData != null && type.lazy() == false) {
+ result.append(fieldsData);
+ }
+
+ result.append('>');
+ return result.toString();
+>>>>>>>
}
}
Added: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/FieldType.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/FieldType.java?rev=1158029&view=auto
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/FieldType.java (added)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/FieldType.java Mon Aug 15 22:03:41 2011
@@ -0,0 +1,183 @@
+package org.apache.lucene.document;
+
+/*
+ * 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.
+ */
+
+public class FieldType {
+
+ private boolean indexed;
+ private boolean stored;
+ private boolean tokenized;
+ private boolean storeTermVectors;
+ private boolean storeTermVectorOffsets;
+ private boolean storeTermVectorPositions;
+ private boolean omitNorms;
+ private boolean omitTermFreqsAndPositions;
+ private boolean lazy;
+ private boolean frozen;
+
+ public FieldType(FieldType ref) {
+ this.indexed = ref.indexed();
+ this.stored = ref.stored();
+ this.tokenized = ref.tokenized();
+ this.storeTermVectors = ref.storeTermVectors();
+ this.storeTermVectorOffsets = ref.storeTermVectorOffsets();
+ this.storeTermVectorPositions = ref.storeTermVectorPositions();
+ this.omitNorms = ref.omitNorms();
+ this.omitTermFreqsAndPositions = ref.omitTermFreqAndPositions();
+ this.lazy = ref.lazy();
+ }
+
+ public FieldType() {
+ }
+
+ private void checkIfFrozen() {
+ if (frozen) {
+ throw new IllegalStateException();
+ }
+ }
+
+ public void freeze() {
+ this.frozen = true;
+ }
+
+ public boolean indexed() {
+ return this.indexed;
+ }
+
+ public void setIndexed(boolean value) {
+ checkIfFrozen();
+ this.indexed = value;
+ }
+
+ public boolean stored() {
+ return this.stored;
+ }
+
+ public void setStored(boolean value) {
+ checkIfFrozen();
+ this.stored = value;
+ }
+
+ public boolean tokenized() {
+ return this.tokenized;
+ }
+
+ public void setTokenized(boolean value) {
+ checkIfFrozen();
+ this.tokenized = value;
+ }
+
+ public boolean storeTermVectors() {
+ return this.storeTermVectors;
+ }
+
+ public void setStoreTermVectors(boolean value) {
+ checkIfFrozen();
+ this.storeTermVectors = value;
+ }
+
+ public boolean storeTermVectorOffsets() {
+ return this.storeTermVectorOffsets;
+ }
+
+ public void setStoreTermVectorOffsets(boolean value) {
+ checkIfFrozen();
+ this.storeTermVectorOffsets = value;
+ }
+
+ public boolean storeTermVectorPositions() {
+ return this.storeTermVectorPositions;
+ }
+
+ public void setStoreTermVectorPositions(boolean value) {
+ checkIfFrozen();
+ this.storeTermVectorPositions = value;
+ }
+
+ public boolean omitNorms() {
+ return this.omitNorms;
+ }
+
+ public void setOmitNorms(boolean value) {
+ checkIfFrozen();
+ this.omitNorms = value;
+ }
+
+ public boolean omitTermFreqAndPositions() {
+ return this.omitTermFreqsAndPositions;
+ }
+
+ public void setOmitTermFreqAndPositions(boolean value) {
+ checkIfFrozen();
+ this.omitTermFreqsAndPositions = value;
+ }
+
+ public boolean lazy() {
+ return this.lazy;
+ }
+
+ public void setLazy(boolean value) {
+ checkIfFrozen();
+ this.lazy = value;
+ }
+
+ /** Prints a Field for human consumption. */
+ @Override
+ public final String toString() {
+ StringBuilder result = new StringBuilder();
+ if (stored()) {
+ result.append("stored");
+ }
+ if (indexed()) {
+ if (result.length() > 0)
+ result.append(",");
+ result.append("indexed");
+ }
+ if (tokenized()) {
+ if (result.length() > 0)
+ result.append(",");
+ result.append("tokenized");
+ }
+ if (storeTermVectors()) {
+ if (result.length() > 0)
+ result.append(",");
+ result.append("termVector");
+ }
+ if (storeTermVectorOffsets()) {
+ if (result.length() > 0)
+ result.append(",");
+ result.append("termVectorOffsets");
+ }
+ if (storeTermVectorPositions()) {
+ if (result.length() > 0)
+ result.append(",");
+ result.append("termVectorPosition");
+ }
+ if (omitNorms()) {
+ result.append(",omitNorms");
+ }
+ if (omitTermFreqAndPositions()) {
+ result.append(",omitTermFreqAndPositions");
+ }
+ if (lazy()){
+ result.append(",lazy");
+ }
+
+ return result.toString();
+ }
+}
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/NumericField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/NumericField.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/NumericField.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/NumericField.java Mon Aug 15 22:03:41 2011
@@ -21,29 +21,34 @@ import java.io.Reader;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.NumericTokenStream;
+<<<<<<<
import org.apache.lucene.index.FieldInfo.IndexOptions;
+=======
+import org.apache.lucene.document.NumericField.DataType;
+>>>>>>>
import org.apache.lucene.util.NumericUtils;
import org.apache.lucene.search.NumericRangeQuery; // javadocs
import org.apache.lucene.search.NumericRangeFilter; // javadocs
import org.apache.lucene.search.FieldCache; // javadocs
/**
- * <p>This class provides a {@link Field} that enables indexing
- * of numeric values for efficient range filtering and
- * sorting. Here's an example usage, adding an int value:
+ * <p>
+ * This class provides a {@link Field} that enables indexing of numeric values
+ * for efficient range filtering and sorting. Here's an example usage, adding an
+ * int value:
+ *
* <pre>
- * document.add(new NumericField(name).setIntValue(value));
+ * document.add(new NumericField(name).setIntValue(value));
* </pre>
- *
- * For optimal performance, re-use the
- * <code>NumericField</code> and {@link Document} instance for more than
- * one document:
- *
+ *
+ * For optimal performance, re-use the <code>NumericField</code> and
+ * {@link Document} instance for more than one document:
+ *
* <pre>
* NumericField field = new NumericField(name);
* Document document = new Document();
* document.add(field);
- *
+ *
* for(all documents) {
* ...
* field.setIntValue(value)
@@ -51,6 +56,7 @@ import org.apache.lucene.search.FieldCac
* ...
* }
* </pre>
+<<<<<<<
*
* <p>The java native types <code>int</code>, <code>long</code>,
* <code>float</code> and <code>double</code> are
@@ -127,96 +133,221 @@ import org.apache.lucene.search.FieldCac
* class is a wrapper around this token stream type for
* easier, more intuitive usage.</p>
*
+=======
+ *
+ * <p>
+ * The java native types <code>int</code>, <code>long</code>, <code>float</code>
+ * and <code>double</code> are directly supported. However, any value that can
+ * be converted into these native types can also be indexed. For example,
+ * date/time values represented by a {@link java.util.Date} can be translated
+ * into a long value using the {@link java.util.Date#getTime} method. If you
+ * don't need millisecond precision, you can quantize the value, either by
+ * dividing the result of {@link java.util.Date#getTime} or using the separate
+ * getters (for year, month, etc.) to construct an <code>int</code> or
+ * <code>long</code> value.
+ * </p>
+ *
+ * <p>
+ * To perform range querying or filtering against a <code>NumericField</code>,
+ * use {@link NumericRangeQuery} or {@link NumericRangeFilter}. To sort
+ * according to a <code>NumericField</code>, use the normal numeric sort types,
+ * eg {@link SortField#INT}. <code>NumericField</code> values can also be loaded
+ * directly from {@link FieldCache}.
+ * </p>
+ *
+ * <p>
+ * By default, a <code>NumericField</code>'s value is not stored but is indexed
+ * for range filtering and sorting. You can use the
+ * {@link #NumericField(String,FieldType)} constructor if you need to
+ * change these defaults, and alter the default field type (set it to stored).
+ * </p>
+ *
+ * <p>
+ * You may add the same field name as a <code>NumericField</code> to the same
+ * document more than once. Range querying and filtering will be the logical OR
+ * of all values; so a range query will hit all documents that have at least one
+ * value in the range. However sort behavior is not defined. If you need to
+ * sort, you should separately index a single-valued <code>NumericField</code>.
+ * </p>
+ *
+ * <p>
+ * A <code>NumericField</code> will consume somewhat more disk space in the
+ * index than an ordinary single-valued field. However, for a typical index that
+ * includes substantial textual content per document, this increase will likely
+ * be in the noise.
+ * </p>
+ *
+ * <p>
+ * Within Lucene, each numeric value is indexed as a <em>trie</em> structure,
+ * where each term is logically assigned to larger and larger pre-defined
+ * brackets (which are simply lower-precision representations of the value). The
+ * step size between each successive bracket is called the
+ * <code>precisionStep</code>, measured in bits. Smaller
+ * <code>precisionStep</code> values result in larger number of brackets, which
+ * consumes more disk space in the index but may result in faster range search
+ * performance. The default value, 4, was selected for a reasonable tradeoff of
+ * disk space consumption versus performance. You can use the expert constructor
+ * {@link #NumericField(String,int,FieldType)} if you'd like to change
+ * the value. Note that you must also specify a congruent value when creating
+ * {@link NumericRangeQuery} or {@link NumericRangeFilter}. For low cardinality
+ * fields larger precision steps are good. If the cardinality is < 100, it is
+ * fair to use {@link Integer#MAX_VALUE}, which produces one term per value.
+ *
+ * <p>
+ * For more information on the internals of numeric trie indexing, including the
+ * <a href="../search/NumericRangeQuery.html#precisionStepDesc">
+ * <code>precisionStep</code></a> configuration, see {@link NumericRangeQuery}.
+ * The format of indexed values is described in {@link NumericUtils}.
+ *
+ * <p>
+ * If you only need to sort by numeric value, and never run range
+ * querying/filtering, you can index using a <code>precisionStep</code> of
+ * {@link Integer#MAX_VALUE}. This will minimize disk space consumed.
+ * </p>
+ *
+ * <p>
+ * More advanced users can instead use {@link NumericTokenStream} directly, when
+ * indexing numbers. This class is a wrapper around this token stream type for
+ * easier, more intuitive usage.
+ * </p>
+ *
+>>>>>>>
* @since 2.9
*/
-public final class NumericField extends AbstractField {
-
+public final class NumericField extends Field {
+
/** Data type of the value in {@link NumericField}.
* @since 3.2
*/
public static enum DataType { INT, LONG, FLOAT, DOUBLE }
+ public static final FieldType TYPE_UNSTORED = new FieldType();
+ public static final FieldType TYPE_STORED = new FieldType();
+ static {
+ TYPE_UNSTORED.setIndexed(true);
+ TYPE_UNSTORED.setTokenized(true);
+ TYPE_UNSTORED.setOmitNorms(true);
+ TYPE_UNSTORED.setOmitTermFreqAndPositions(true);
+ TYPE_UNSTORED.freeze();
+
+ TYPE_STORED.setIndexed(true);
+ TYPE_STORED.setStored(true);
+ TYPE_STORED.setTokenized(true);
+ TYPE_STORED.setOmitNorms(true);
+ TYPE_STORED.setOmitTermFreqAndPositions(true);
+ TYPE_STORED.freeze();
+ }
+
+ //public static enum DataType { INT, LONG, FLOAT, DOUBLE }
+
+ private DataType dataType;
private transient NumericTokenStream numericTS;
- private DataType type;
private final int precisionStep;
-
+
/**
- * Creates a field for numeric values using the default <code>precisionStep</code>
- * {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). The instance is not yet initialized with
- * a numeric value, before indexing a document containing this field,
- * set a value using the various set<em>???</em>Value() methods.
- * This constructor creates an indexed, but not stored field.
- * @param name the field name
+ * Creates a field for numeric values using the default
+ * <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ * The instance is not yet initialized with a numeric value, before indexing a
+ * document containing this field, set a value using the various set
+ * <em>???</em>Value() methods. This constructor creates an indexed, but not
+ * stored field.
+ *
+ * @param name
+ * the field name
*/
public NumericField(String name) {
- this(name, NumericUtils.PRECISION_STEP_DEFAULT, Field.Store.NO, true);
+ this(name, NumericUtils.PRECISION_STEP_DEFAULT, NumericField.TYPE_UNSTORED);
}
/**
- * Creates a field for numeric values using the default <code>precisionStep</code>
- * {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). The instance is not yet initialized with
- * a numeric value, before indexing a document containing this field,
- * set a value using the various set<em>???</em>Value() methods.
- * @param name the field name
- * @param store if the field should be stored, {@link Document#getFieldable}
- * then returns {@code NumericField} instances on search results.
- * @param index if the field should be indexed using {@link NumericTokenStream}
+ * Creates a field for numeric values using the default
+ * <code>precisionStep</code> {@link NumericUtils#PRECISION_STEP_DEFAULT} (4).
+ * The instance is not yet initialized with a numeric value, before indexing a
+ * document containing this field, set a value using the various set
+ * <em>???</em>Value() methods.
+ *
+ * @param name
+ * the field name
+ * @param type
+ * if the defualt field should be altered, e.g. stored,
+ * {@link Document#getField} then returns {@code NumericField}
+ * instances on search results, or indexed using
+ * {@link NumericTokenStream}
*/
- public NumericField(String name, Field.Store store, boolean index) {
- this(name, NumericUtils.PRECISION_STEP_DEFAULT, store, index);
+ public NumericField(String name, FieldType type) {
+ this(name, NumericUtils.PRECISION_STEP_DEFAULT, type);
}
/**
* Creates a field for numeric values with the specified
- * <code>precisionStep</code>. The instance is not yet initialized with
- * a numeric value, before indexing a document containing this field,
- * set a value using the various set<em>???</em>Value() methods.
- * This constructor creates an indexed, but not stored field.
- * @param name the field name
- * @param precisionStep the used <a href="../search/NumericRangeQuery.html#precisionStepDesc">precision step</a>
+ * <code>precisionStep</code>. The instance is not yet initialized with a
+ * numeric value, before indexing a document containing this field, set a
+ * value using the various set<em>???</em>Value() methods. This constructor
+ * creates an indexed, but not stored field.
+ *
+ * @param name
+ * the field name
+ * @param precisionStep
+ * the used <a
+ * href="../search/NumericRangeQuery.html#precisionStepDesc"
+ * >precision step</a>
*/
public NumericField(String name, int precisionStep) {
- this(name, precisionStep, Field.Store.NO, true);
+ this(name, precisionStep, NumericField.TYPE_UNSTORED);
}
-
+
/**
* Creates a field for numeric values with the specified
- * <code>precisionStep</code>. The instance is not yet initialized with
- * a numeric value, before indexing a document containing this field,
- * set a value using the various set<em>???</em>Value() methods.
- * @param name the field name
- * @param precisionStep the used <a href="../search/NumericRangeQuery.html#precisionStepDesc">precision step</a>
- * @param store if the field should be stored, {@link Document#getFieldable}
- * then returns {@code NumericField} instances on search results.
- * @param index if the field should be indexed using {@link NumericTokenStream}
+ * <code>precisionStep</code>. The instance is not yet initialized with a
+ * numeric value, before indexing a document containing this field, set a
+ * value using the various set<em>???</em>Value() methods.
+ *
+ * @param name
+ * the field name
+ * @param precisionStep
+ * the used <a
+ * href="../search/NumericRangeQuery.html#precisionStepDesc"
+ * >precision step</a>
+ * @param type
+ * if the defualt field should be altered, e.g. stored,
+ * {@link Document#getField} then returns {@code NumericField}
+ * instances on search results, or indexed using
+ * {@link NumericTokenStream}
*/
- public NumericField(String name, int precisionStep, Field.Store store, boolean index) {
- super(name, store, index ? Field.Index.ANALYZED_NO_NORMS : Field.Index.NO, Field.TermVector.NO);
+ public NumericField(String name, int precisionStep, FieldType type) {
+ super(name, type);
this.precisionStep = precisionStep;
+<<<<<<<
setIndexOptions(IndexOptions.DOCS_ONLY);
+=======
+>>>>>>>
}
-
+
/** Returns a {@link NumericTokenStream} for indexing the numeric value. */
- public TokenStream tokenStreamValue() {
- if (!isIndexed())
- return null;
+ public TokenStream tokenStreamValue() {
+ if (!indexed()) return null;
if (numericTS == null) {
- // lazy init the TokenStream as it is heavy to instantiate (attributes,...),
+ // lazy init the TokenStream as it is heavy to instantiate
+ // (attributes,...),
// if not needed (stored field loading)
numericTS = new NumericTokenStream(precisionStep);
// initialize value in TokenStream
if (fieldsData != null) {
- assert type != null;
+ assert dataType != null;
final Number val = (Number) fieldsData;
- switch (type) {
+ switch (dataType) {
case INT:
- numericTS.setIntValue(val.intValue()); break;
+ numericTS.setIntValue(val.intValue());
+ break;
case LONG:
- numericTS.setLongValue(val.longValue()); break;
+ numericTS.setLongValue(val.longValue());
+ break;
case FLOAT:
- numericTS.setFloatValue(val.floatValue()); break;
+ numericTS.setFloatValue(val.floatValue());
+ break;
case DOUBLE:
- numericTS.setDoubleValue(val.doubleValue()); break;
+ numericTS.setDoubleValue(val.doubleValue());
+ break;
default:
assert false : "Should never get here";
}
@@ -226,26 +357,27 @@ public final class NumericField extends
}
/** Returns always <code>null</code> for numeric fields */
- @Override
- public byte[] getBinaryValue(byte[] result){
- return null;
- }
-
- /** Returns always <code>null</code> for numeric fields */
public Reader readerValue() {
return null;
}
-
- /** Returns the numeric value as a string. This format is also returned if you call {@link Document#get(String)}
- * on search results. It is recommended to use {@link Document#getFieldable} instead
- * that returns {@code NumericField} instances. You can then use {@link #getNumericValue}
- * to return the stored value. */
- public String stringValue() {
+
+ /**
+ * Returns the numeric value as a string. It is recommended to
+ * use {@link Document#getField} instead that returns {@code NumericField}
+ * instances. You can then use {@link #numericValue} to return the stored
+ * value.
+ */
+ @Override
+ public String stringValue() {
return (fieldsData == null) ? null : fieldsData.toString();
}
- /** Returns the current numeric value as a subclass of {@link Number}, <code>null</code> if not yet initialized. */
- public Number getNumericValue() {
+ /**
+ * Returns the current numeric value as a subclass of {@link Number},
+ * <code>null</code> if not yet initialized.
+ */
+ @Override
+ public Number numericValue() {
return (Number) fieldsData;
}
@@ -254,63 +386,88 @@ public final class NumericField extends
return precisionStep;
}
- /** Returns the data type of the current value, {@code null} if not yet set.
+ /**
+ * Returns the data type of the current value, {@code null} if not yet set.
+ *
* @since 3.2
*/
- public DataType getDataType() {
- return type;
+ @Override
+ public DataType numericDataType() {
+ return dataType;
+ }
+
+ public DataType numericType() {
+ return dataType;
+ }
+
+ @Override
+ public boolean numeric() {
+ return true;
+ }
+
+ @Override
+ public boolean isNumeric() {
+ return true;
}
/**
* Initializes the field with the supplied <code>long</code> value.
- * @param value the numeric value
+ *
+ * @param value
+ * the numeric value
* @return this instance, because of this you can use it the following way:
- * <code>document.add(new NumericField(name, precisionStep).setLongValue(value))</code>
+ * <code>document.add(new NumericField(name, precisionStep).setLongValue(value))</code>
*/
public NumericField setLongValue(final long value) {
if (numericTS != null) numericTS.setLongValue(value);
fieldsData = Long.valueOf(value);
- type = DataType.LONG;
+ dataType = DataType.LONG;
return this;
}
/**
* Initializes the field with the supplied <code>int</code> value.
- * @param value the numeric value
+ *
+ * @param value
+ * the numeric value
* @return this instance, because of this you can use it the following way:
- * <code>document.add(new NumericField(name, precisionStep).setIntValue(value))</code>
+ * <code>document.add(new NumericField(name, precisionStep).setIntValue(value))</code>
*/
public NumericField setIntValue(final int value) {
if (numericTS != null) numericTS.setIntValue(value);
fieldsData = Integer.valueOf(value);
- type = DataType.INT;
+ dataType = DataType.INT;
return this;
}
/**
* Initializes the field with the supplied <code>double</code> value.
- * @param value the numeric value
+ *
+ * @param value
+ * the numeric value
* @return this instance, because of this you can use it the following way:
- * <code>document.add(new NumericField(name, precisionStep).setDoubleValue(value))</code>
+ * <code>document.add(new NumericField(name, precisionStep).setDoubleValue(value))</code>
*/
public NumericField setDoubleValue(final double value) {
if (numericTS != null) numericTS.setDoubleValue(value);
fieldsData = Double.valueOf(value);
- type = DataType.DOUBLE;
+ dataType = DataType.DOUBLE;
return this;
}
/**
* Initializes the field with the supplied <code>float</code> value.
- * @param value the numeric value
+ *
+ * @param value
+ * the numeric value
* @return this instance, because of this you can use it the following way:
- * <code>document.add(new NumericField(name, precisionStep).setFloatValue(value))</code>
+ * <code>document.add(new NumericField(name, precisionStep).setFloatValue(value))</code>
*/
public NumericField setFloatValue(final float value) {
if (numericTS != null) numericTS.setFloatValue(value);
fieldsData = Float.valueOf(value);
- type = DataType.FLOAT;
+ dataType = DataType.FLOAT;
return this;
}
-
+
}
Added: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/StringField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/StringField.java?rev=1158029&view=auto
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/StringField.java (added)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/StringField.java Mon Aug 15 22:03:41 2011
@@ -0,0 +1,53 @@
+package org.apache.lucene.document;
+
+/**
+ * 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.
+ */
+
+public final class StringField extends Field {
+
+ public static final FieldType TYPE_UNSTORED = new FieldType();
+ public static final FieldType TYPE_STORED = new FieldType();
+ static {
+ TYPE_UNSTORED.setIndexed(true);
+ TYPE_UNSTORED.setOmitNorms(true);
+ TYPE_UNSTORED.setOmitTermFreqAndPositions(true);
+ TYPE_UNSTORED.freeze();
+
+ TYPE_STORED.setIndexed(true);
+ TYPE_STORED.setStored(true);
+ TYPE_STORED.setOmitNorms(true);
+ TYPE_STORED.setOmitTermFreqAndPositions(true);
+ TYPE_STORED.freeze();
+ }
+
+ public StringField(String name, boolean internName, String value) {
+ super(name, StringField.TYPE_UNSTORED, value);
+ }
+
+ public StringField(String name, String value) {
+ this(name, true, value);
+ }
+
+ @Override
+ public String stringValue() {
+ return (fieldsData == null) ? null : fieldsData.toString();
+ }
+
+ public boolean isNumeric() {
+ return false;
+ }
+}
Added: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/TextField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/TextField.java?rev=1158029&view=auto
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/TextField.java (added)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/document/TextField.java Mon Aug 15 22:03:41 2011
@@ -0,0 +1,54 @@
+package org.apache.lucene.document;
+
+/**
+ * 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.
+ */
+
+import java.io.Reader;
+
+import org.apache.lucene.analysis.TokenStream;
+
+public final class TextField extends Field {
+
+ public static final FieldType TYPE_UNSTORED = new FieldType();
+ public static final FieldType TYPE_STORED = new FieldType();
+ static {
+ TYPE_UNSTORED.setIndexed(true);
+ TYPE_UNSTORED.setTokenized(true);
+ TYPE_UNSTORED.freeze();
+
+ TYPE_STORED.setIndexed(true);
+ TYPE_STORED.setStored(true);
+ TYPE_STORED.setTokenized(true);
+ TYPE_STORED.freeze();
+ }
+
+ public TextField(String name, Reader reader) {
+ super(name, TextField.TYPE_UNSTORED, reader);
+ }
+
+ public TextField(String name, String value) {
+ super(name, TextField.TYPE_UNSTORED, value);
+ }
+
+ public TextField(String name, TokenStream stream) {
+ super(name, TextField.TYPE_UNSTORED, stream);
+ }
+
+ public boolean isNumeric() {
+ return false;
+ }
+}
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/CheckIndex.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/CheckIndex.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/CheckIndex.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/CheckIndex.java Mon Aug 15 22:03:41 2011
@@ -17,6 +17,7 @@ package org.apache.lucene.index;
* limitations under the License.
*/
+import org.apache.lucene.document.FieldType; // for javadocs
import org.apache.lucene.search.DocIdSetIterator;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.TermQuery;
@@ -24,6 +25,12 @@ import org.apache.lucene.store.FSDirecto
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.IOContext;
import org.apache.lucene.store.IndexInput;
+<<<<<<<
+=======
+import org.apache.lucene.document.Document;
+import org.apache.lucene.index.codecs.CodecProvider;
+import org.apache.lucene.index.codecs.DefaultSegmentInfosWriter;
+>>>>>>>
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
@@ -186,8 +193,13 @@ public class CheckIndex {
int numFields;
/** True if at least one of the fields in this segment
+<<<<<<<
* has position data
* @see AbstractField#setIndexOptions(org.apache.lucene.index.FieldInfo.IndexOptions) */
+=======
+ * does not omitTermFreqAndPositions.
+ * @see FieldType#setOmitTermFreqAndPositions */
+>>>>>>>
public boolean hasProx;
/** Map that includes certain
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DirectoryReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DirectoryReader.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DirectoryReader.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DirectoryReader.java Mon Aug 15 22:03:41 2011
@@ -29,8 +29,6 @@ import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.FieldSelector;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.IOContext;
import org.apache.lucene.store.Lock;
@@ -559,12 +557,11 @@ class DirectoryReader extends IndexReade
return maxDoc;
}
- // inherit javadoc
@Override
- public Document document(int n, FieldSelector fieldSelector) throws CorruptIndexException, IOException {
+ public void document(int docID, StoredFieldVisitor visitor) throws CorruptIndexException, IOException {
ensureOpen();
- int i = readerIndex(n); // find segment num
- return subReaders[i].document(n - starts[i], fieldSelector); // dispatch to segment reader
+ int i = readerIndex(docID); // find segment num
+ subReaders[i].document(docID - starts[i], visitor); // dispatch to segment reader
}
@Override
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumerPerField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumerPerField.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumerPerField.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumerPerField.java Mon Aug 15 22:03:41 2011
@@ -18,11 +18,10 @@ package org.apache.lucene.index;
*/
import java.io.IOException;
-import org.apache.lucene.document.Fieldable;
abstract class DocFieldConsumerPerField {
/** Processes all occurrences of a single field */
- abstract void processFields(Fieldable[] fields, int count) throws IOException;
+ abstract void processFields(IndexableField[] fields, int count) throws IOException;
abstract void abort();
abstract FieldInfo getFieldInfo();
}
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumersPerField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumersPerField.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumersPerField.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldConsumersPerField.java Mon Aug 15 22:03:41 2011
@@ -18,7 +18,6 @@ package org.apache.lucene.index;
*/
import java.io.IOException;
-import org.apache.lucene.document.Fieldable;
final class DocFieldConsumersPerField extends DocFieldConsumerPerField {
@@ -35,7 +34,7 @@ final class DocFieldConsumersPerField ex
}
@Override
- public void processFields(Fieldable[] fields, int count) throws IOException {
+ public void processFields(IndexableField[] fields, int count) throws IOException {
one.processFields(fields, count);
two.processFields(fields, count);
}
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessor.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessor.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessor.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessor.java Mon Aug 15 22:03:41 2011
@@ -22,11 +22,16 @@ import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.List;
import java.util.Map;
+<<<<<<<
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Fieldable;
+=======
+import org.apache.lucene.util.ArrayUtil;
+
+
+>>>>>>>
import org.apache.lucene.index.DocumentsWriterPerThread.DocState;
import org.apache.lucene.index.codecs.Codec;
import org.apache.lucene.index.codecs.PerDocConsumer;
@@ -199,22 +204,16 @@ final class DocFieldProcessor extends Do
consumer.startDocument();
fieldsWriter.startDocument();
- final Document doc = docState.doc;
-
fieldCount = 0;
final int thisFieldGen = fieldGen++;
- final List<Fieldable> docFields = doc.getFields();
- final int numDocFields = docFields.size();
-
// Absorb any new fields first seen in this document.
// Also absorb any changes to fields we had already
// seen before (eg suddenly turning on norms or
// vectors, etc.):
- for(int i=0;i<numDocFields;i++) {
- Fieldable field = docFields.get(i);
+ for(IndexableField field : docState.doc) {
final String fieldName = field.name();
// Make sure we have a PerField allocated
@@ -231,21 +230,34 @@ final class DocFieldProcessor extends Do
// needs to be more "pluggable" such that if I want
// to have a new "thing" my Fields can do, I can
// easily add it
+<<<<<<<
FieldInfo fi = fieldInfos.addOrUpdate(fieldName, field.isIndexed(), field.isTermVectorStored(),
field.isStorePositionWithTermVector(), field.isStoreOffsetWithTermVector(),
field.getOmitNorms(), false, field.getIndexOptions(), field.docValuesType());
+=======
+ FieldInfo fi = fieldInfos.addOrUpdate(fieldName, field.indexed(), field.storeTermVectors(),
+ field.storeTermVectorPositions(), field.storeTermVectorOffsets(),
+ field.omitNorms(), false, field.omitTermFreqAndPositions());
+>>>>>>>
fp = new DocFieldProcessorPerField(this, fi);
fp.next = fieldHash[hashPos];
fieldHash[hashPos] = fp;
totalFieldCount++;
- if (totalFieldCount >= fieldHash.length/2)
+ if (totalFieldCount >= fieldHash.length/2) {
rehash();
+ }
} else {
+<<<<<<<
fieldInfos.addOrUpdate(fp.fieldInfo.name, field.isIndexed(), field.isTermVectorStored(),
field.isStorePositionWithTermVector(), field.isStoreOffsetWithTermVector(),
field.getOmitNorms(), false, field.getIndexOptions(), field.docValuesType());
+=======
+ fieldInfos.addOrUpdate(fp.fieldInfo.name, field.indexed(), field.storeTermVectors(),
+ field.storeTermVectorPositions(), field.storeTermVectorOffsets(),
+ field.omitNorms(), false, field.omitTermFreqAndPositions());
+>>>>>>>
}
if (thisFieldGen != fp.lastGen) {
@@ -266,7 +278,7 @@ final class DocFieldProcessor extends Do
fp.addField(field);
- if (field.isStored()) {
+ if (field.stored()) {
fieldsWriter.addField(field, fp.fieldInfo);
}
if (field.hasDocValues()) {
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessorPerField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessorPerField.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessorPerField.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocFieldProcessorPerField.java Mon Aug 15 22:03:41 2011
@@ -17,7 +17,6 @@ package org.apache.lucene.index;
* limitations under the License.
*/
-import org.apache.lucene.document.Fieldable;
import org.apache.lucene.util.ArrayUtil;
import org.apache.lucene.util.RamUsageEstimator;
@@ -34,17 +33,17 @@ final class DocFieldProcessorPerField {
int lastGen = -1;
int fieldCount;
- Fieldable[] fields = new Fieldable[1];
+ IndexableField[] fields = new IndexableField[1];
public DocFieldProcessorPerField(final DocFieldProcessor docFieldProcessor, final FieldInfo fieldInfo) {
this.consumer = docFieldProcessor.consumer.addField(fieldInfo);
this.fieldInfo = fieldInfo;
}
- public void addField(Fieldable field) {
+ public void addField(IndexableField field) {
if (fieldCount == fields.length) {
int newSize = ArrayUtil.oversize(fieldCount + 1, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
- Fieldable[] newArray = new Fieldable[newSize];
+ IndexableField[] newArray = new IndexableField[newSize];
System.arraycopy(fields, 0, newArray, 0, fieldCount);
fields = newArray;
}
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocInverterPerField.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocInverterPerField.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocInverterPerField.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocInverterPerField.java Mon Aug 15 22:03:41 2011
@@ -19,7 +19,6 @@ package org.apache.lucene.index;
import java.io.IOException;
import java.io.Reader;
-import org.apache.lucene.document.Fieldable;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
@@ -61,26 +60,29 @@ final class DocInverterPerField extends
}
@Override
- public void processFields(final Fieldable[] fields,
+ public void processFields(final IndexableField[] fields,
final int count) throws IOException {
- fieldState.reset(docState.doc.getBoost());
+ fieldState.reset();
final boolean doInvert = consumer.start(fields, count);
for(int i=0;i<count;i++) {
- final Fieldable field = fields[i];
+ final IndexableField field = fields[i];
// TODO FI: this should be "genericized" to querying
// consumer if it wants to see this particular field
// tokenized.
- if (field.isIndexed() && doInvert) {
+ if (field.indexed() && doInvert) {
if (i > 0)
fieldState.position += docState.analyzer == null ? 0 : docState.analyzer.getPositionIncrementGap(fieldInfo.name);
- if (!field.isTokenized()) { // un-tokenized field
+ // nocommit -- this logic should be outside of
+ // indexer
+
+ if (!field.tokenized()) { // un-tokenized field
String stringValue = field.stringValue();
final int valueLength = stringValue.length();
parent.singleToken.reinit(stringValue, 0, valueLength);
@@ -103,17 +105,17 @@ final class DocInverterPerField extends
final TokenStream stream;
final TokenStream streamValue = field.tokenStreamValue();
- if (streamValue != null)
+ if (streamValue != null) {
stream = streamValue;
- else {
+ } else {
// the field does not have a TokenStream,
// so we have to obtain one from the analyzer
final Reader reader; // find or make Reader
final Reader readerValue = field.readerValue();
- if (readerValue != null)
+ if (readerValue != null) {
reader = readerValue;
- else {
+ } else {
String stringValue = field.stringValue();
if (stringValue == null) {
throw new IllegalArgumentException("field must have either TokenStream, String or Reader value");
@@ -188,8 +190,13 @@ final class DocInverterPerField extends
}
}
+<<<<<<<
fieldState.offset += docState.analyzer == null ? 0 : docState.analyzer.getOffsetGap(field);
fieldState.boost *= field.getBoost();
+=======
+ fieldState.offset += docState.analyzer.getOffsetGap(field);
+ fieldState.boost *= field.boost();
+>>>>>>>
}
// LUCENE-2387: don't hang onto the field, so GC can
Added: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentStoredFieldVisitor.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentStoredFieldVisitor.java?rev=1158029&view=auto
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentStoredFieldVisitor.java (added)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentStoredFieldVisitor.java Mon Aug 15 22:03:41 2011
@@ -0,0 +1,141 @@
+package org.apache.lucene.index;
+
+/**
+ * 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.
+ */
+
+import java.io.IOException;
+import java.util.Set;
+import java.util.HashSet;
+
+import org.apache.lucene.document.BinaryField;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.FieldType;
+import org.apache.lucene.document.NumericField;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.store.IndexInput;
+
+/** A {@link StoredFieldVisitor} that creates a {@link
+ * Document} containing all stored fields, or only specific
+ * requested fields provided to {@link #DocumentStoredFieldVisitor(Set)}
+ * This is used by {@link IndexReader#document(int)} to load a
+ * document.
+ *
+ * @lucene.experimental */
+
+public class DocumentStoredFieldVisitor extends StoredFieldVisitor {
+ private final Document doc = new Document();
+ private final Set<String> fieldsToAdd;
+
+ /** Load only fields named in the provided <code>Set<String></code>. */
+ public DocumentStoredFieldVisitor(Set<String> fieldsToAdd) {
+ this.fieldsToAdd = fieldsToAdd;
+ }
+
+ /** Load only fields named in the provided <code>Set<String></code>. */
+ public DocumentStoredFieldVisitor(String... fields) {
+ fieldsToAdd = new HashSet<String>(fields.length);
+ for(String field : fields) {
+ fieldsToAdd.add(field);
+ }
+ }
+
+ /** Load all stored fields. */
+ public DocumentStoredFieldVisitor() {
+ this.fieldsToAdd = null;
+ }
+
+ @Override
+ public boolean binaryField(FieldInfo fieldInfo, IndexInput in, int numBytes) throws IOException {
+ if (accept(fieldInfo)) {
+ final byte[] b = new byte[numBytes];
+ in.readBytes(b, 0, b.length);
+ doc.add(new BinaryField(fieldInfo.name, b));
+ } else {
+ in.seek(in.getFilePointer() + numBytes);
+ }
+ return false;
+ }
+
+ @Override
+ public boolean stringField(FieldInfo fieldInfo, IndexInput in, int numUTF8Bytes) throws IOException {
+ if (accept(fieldInfo)) {
+ final byte[] b = new byte[numUTF8Bytes];
+ in.readBytes(b, 0, b.length);
+ FieldType ft = new FieldType(TextField.TYPE_STORED);
+ ft.setStoreTermVectors(fieldInfo.storeTermVector);
+ ft.setStoreTermVectorPositions(fieldInfo.storePositionWithTermVector);
+ ft.setStoreTermVectorOffsets(fieldInfo.storeOffsetWithTermVector);
+ ft.setStoreTermVectors(fieldInfo.storeTermVector);
+ doc.add(new Field(fieldInfo.name,
+ false,
+ ft,
+ new String(b, "UTF-8")));
+ } else {
+ in.seek(in.getFilePointer() + numUTF8Bytes);
+ }
+ return false;
+ }
+
+ @Override
+ public boolean intField(FieldInfo fieldInfo, int value) {
+ if (accept(fieldInfo)) {
+ FieldType ft = new FieldType(NumericField.TYPE_STORED);
+ ft.setIndexed(fieldInfo.isIndexed);
+ doc.add(new NumericField(fieldInfo.name, ft).setIntValue(value));
+ }
+ return false;
+ }
+
+ @Override
+ public boolean longField(FieldInfo fieldInfo, long value) {
+ if (accept(fieldInfo)) {
+ FieldType ft = new FieldType(NumericField.TYPE_STORED);
+ ft.setIndexed(fieldInfo.isIndexed);
+ doc.add(new NumericField(fieldInfo.name, ft).setLongValue(value));
+ }
+ return false;
+ }
+
+ @Override
+ public boolean floatField(FieldInfo fieldInfo, float value) {
+ if (accept(fieldInfo)) {
+ FieldType ft = new FieldType(NumericField.TYPE_STORED);
+ ft.setIndexed(fieldInfo.isIndexed);
+ doc.add(new NumericField(fieldInfo.name, ft).setFloatValue(value));
+ }
+ return false;
+ }
+
+ @Override
+ public boolean doubleField(FieldInfo fieldInfo, double value) {
+ if (accept(fieldInfo)) {
+ FieldType ft = new FieldType(NumericField.TYPE_STORED);
+ ft.setIndexed(fieldInfo.isIndexed);
+ doc.add(new NumericField(fieldInfo.name, ft).setDoubleValue(value));
+ }
+ return false;
+ }
+
+ private boolean accept(FieldInfo fieldInfo) {
+ return fieldsToAdd == null || fieldsToAdd.contains(fieldInfo.name);
+ }
+
+ public Document getDocument() {
+ return doc;
+ }
+}
\ No newline at end of file
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java Mon Aug 15 22:03:41 2011
@@ -27,7 +27,6 @@ import java.util.Queue;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.document.Document;
import org.apache.lucene.index.DocumentsWriterPerThread.FlushedSegment;
import org.apache.lucene.index.DocumentsWriterPerThread.IndexingChain;
import org.apache.lucene.index.DocumentsWriterPerThreadPool.ThreadState;
@@ -320,7 +319,7 @@ final class DocumentsWriter {
return maybeMerge;
}
- boolean updateDocuments(final Iterable<Document> docs, final Analyzer analyzer,
+ boolean updateDocuments(final Iterable<? extends Iterable<? extends IndexableField>> docs, final Analyzer analyzer,
final Term delTerm) throws CorruptIndexException, IOException {
boolean maybeMerge = preUpdate();
@@ -351,7 +350,7 @@ final class DocumentsWriter {
return postUpdate(flushingDWPT, maybeMerge);
}
- boolean updateDocument(final Document doc, final Analyzer analyzer,
+ boolean updateDocument(final Iterable<? extends IndexableField> doc, final Analyzer analyzer,
final Term delTerm) throws CorruptIndexException, IOException {
boolean maybeMerge = preUpdate();
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java Mon Aug 15 22:03:41 2011
@@ -26,7 +26,6 @@ import java.text.NumberFormat;
import java.util.concurrent.atomic.AtomicLong;
import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.document.Document;
import org.apache.lucene.index.DocumentsWriterDeleteQueue.DeleteSlice;
import org.apache.lucene.search.SimilarityProvider;
import org.apache.lucene.store.Directory;
@@ -90,7 +89,7 @@ public class DocumentsWriterPerThread {
PrintStream infoStream;
SimilarityProvider similarityProvider;
int docID;
- Document doc;
+ Iterable<? extends IndexableField> doc;
String maxTermPrefix;
DocState(DocumentsWriterPerThread docWriter) {
@@ -213,7 +212,7 @@ public class DocumentsWriterPerThread {
return retval;
}
- public void updateDocument(Document doc, Analyzer analyzer, Term delTerm) throws IOException {
+ public void updateDocument(Iterable<? extends IndexableField> doc, Analyzer analyzer, Term delTerm) throws IOException {
assert writer.testPoint("DocumentsWriterPerThread addDocument start");
assert deleteQueue != null;
docState.doc = doc;
@@ -263,7 +262,7 @@ public class DocumentsWriterPerThread {
finishDocument(delTerm);
}
- public int updateDocuments(Iterable<Document> docs, Analyzer analyzer, Term delTerm) throws IOException {
+ public int updateDocuments(Iterable<? extends Iterable<? extends IndexableField>> docs, Analyzer analyzer, Term delTerm) throws IOException {
assert writer.testPoint("DocumentsWriterPerThread addDocuments start");
assert deleteQueue != null;
docState.analyzer = analyzer;
@@ -280,7 +279,7 @@ public class DocumentsWriterPerThread {
}
int docCount = 0;
try {
- for(Document doc : docs) {
+ for(Iterable<? extends IndexableField> doc : docs) {
docState.doc = doc;
docState.docID = numDocsInRAM;
docCount++;
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfo.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfo.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfo.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfo.java Mon Aug 15 22:03:41 2011
@@ -30,9 +30,9 @@ public final class FieldInfo {
// true if term vector for this field should be stored
- boolean storeTermVector;
- boolean storeOffsetWithTermVector;
- boolean storePositionWithTermVector;
+ public boolean storeTermVector;
+ public boolean storeOffsetWithTermVector;
+ public boolean storePositionWithTermVector;
public boolean omitNorms; // omit norms associated with indexed fields
public IndexOptions indexOptions;
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfos.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfos.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfos.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInfos.java Mon Aug 15 22:03:41 2011
@@ -39,8 +39,8 @@ import org.apache.lucene.store.IndexInpu
import org.apache.lucene.store.IndexOutput;
import org.apache.lucene.util.CodecUtil;
-/** Access to the Fieldable Info file that describes document fields and whether or
- * not they are indexed. Each segment has a separate Fieldable Info file. Objects
+/** Access to the Field Info file that describes document fields and whether or
+ * not they are indexed. Each segment has a separate Field Info file. Objects
* of this class are thread-safe for multiple readers, but only one thread can
* be adding documents at a time, with no other reader or writer threads
* accessing this object.
@@ -381,7 +381,7 @@ public final class FieldInfos implements
/**
* Calls 5 parameter add with false for all TermVector parameters.
*
- * @param name The name of the Fieldable
+ * @param name The name of the IndexableField
* @param isIndexed true if the field is indexed
* @see #addOrUpdate(String, boolean, boolean, boolean, boolean)
*/
Modified: lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInvertState.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInvertState.java?rev=1158029&r1=1158028&r2=1158029&view=diff
==============================================================================
--- lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInvertState.java (original)
+++ lucene/dev/branches/fieldtype_conflicted/lucene/src/java/org/apache/lucene/index/FieldInvertState.java Mon Aug 15 22:03:41 2011
@@ -50,14 +50,18 @@ public final class FieldInvertState {
* Re-initialize the state, using this boost value.
* @param docBoost boost value to use.
*/
- void reset(float docBoost) {
+ void reset() {
position = 0;
length = 0;
numOverlap = 0;
offset = 0;
maxTermFrequency = 0;
+<<<<<<<
uniqueTermCount = 0;
boost = docBoost;
+=======
+ boost = 1.0f;
+>>>>>>>
attributeSource = null;
}