Note that fields which are not {@link Fieldable#isStored() stored} are
+ * not available in documents retrieved from the index, e.g. with {@link
+ * ScoreDoc#doc} or {@link IndexReader#document(int)}.
+ */
+
+public final class Document implements Iterable Adds a field to a document. Several fields may be added with
+ * the same name. In this case, if the fields are indexed, their text is
+ * treated as though appended for the purposes of search. Note that add like the removeField(s) methods only makes sense
+ * prior to adding a document to an index. These methods cannot
+ * be used to change the content of an existing index! In order to achieve this,
+ * a document has to be deleted from an index and a new changed version of that
+ * document has to be added. Removes field with the specified name from the document.
+ * If multiple fields exist with this name, this method removes the first field that has been added.
+ * If there is no field with the specified name, the document remains unchanged. Note that the removeField(s) methods like the add method only make sense
+ * prior to adding a document to an index. These methods cannot
+ * be used to change the content of an existing index! In order to achieve this,
+ * a document has to be deleted from an index and a new changed version of that
+ * document has to be added. Removes all fields with the given name from the document.
+ * If there is no field with the specified name, the document remains unchanged. Note that the removeField(s) methods like the add method only make sense
+ * prior to adding a document to an index. These methods cannot
+ * be used to change the content of an existing index! In order to achieve this,
+ * a document has to be deleted from an index and a new changed version of that
+ * document has to be added.
+ * 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.
+ *
+ * Each Field instance should only be used once within a single
+ * {@link Document} instance. See ImproveIndexingSpeed for details.
+ *
+ * The boost is multiplied by
+ * {@link org.apache.lucene.document.Document#getBoost()} of the document
+ * containing this field. If a document has multiple fields with the same
+ * name, all such values are multiplied together. This product is then 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.document.Document#setBoost(float)
+ * @see org.apache.lucene.search.Similarity#computeNorm(FieldInvertState)
+ * @see org.apache.lucene.search.Similarity#encodeNormValue(float)
+ */
+ public void setBoost(float boost) {
+ this.boost = boost;
+ }
+
+ public boolean numeric() {
+ return false;
+ }
+
+ public Number numericValue() {
+ return null;
+ }
+
+ public NumericField.DataType numericDataType() {
+ return null;
+ }
+
+ 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;
+ }
+ }
+
+ /**
+ * Returns length of byte[] segment that is used as value, if Field is not
+ * binary returned value is undefined
+ *
+ * @return length of byte[] segment that represents this Field value
+ */
+ private int getBinaryLength() {
+ if (isBinary) {
+ return binaryLength;
+ } else if (fieldsData instanceof byte[]) return ((byte[]) fieldsData).length;
+ else return 0;
+ }
+
+ /**
+ * Returns offset into byte[] segment that is used as value, if Field is not
+ * binary returned value is undefined
+ *
+ * @return index of the first character in byte[] segment that represents this
+ * Field value
+ */
+ 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 (fieldsData != null && type.lazy() == false) {
+ result.append(fieldsData);
+ }
+
+ result.append('>');
+ return result.toString();
+ }
+}
Index: lucene/src/java/org/apache/lucene/document2/FieldSelector.java
===================================================================
--- lucene/src/java/org/apache/lucene/document2/FieldSelector.java (revision 0)
+++ lucene/src/java/org/apache/lucene/document2/FieldSelector.java (revision 0)
@@ -0,0 +1,33 @@
+package org.apache.lucene.document2;
+
+/**
+ * Copyright 2004 The Apache Software Foundation
+ *
+ * Licensed 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.
+ */
+
+/**
+ * Similar to a {@link java.io.FileFilter}, the FieldSelector allows one to make decisions about
+ * what Fields get loaded on a {@link Document} by {@link org.apache.lucene.index.IndexReader#document(int,org.apache.lucene.document.FieldSelector)}
+ *
+ **/
+public interface FieldSelector {
+
+ /**
+ *
+ * @param fieldName the field to accept or reject
+ * @return an instance of {@link FieldSelectorResult}
+ * if the {@link Field} named
+ * 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:
+ *
+ *
+ * The java native types
+ * To perform range querying or filtering against a
+ * By default, a
+ * You may add the same field name as a
+ * A
+ * Within Lucene, each numeric value is indexed as a trie 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
+ *
+ * For more information on the internals of numeric trie indexing, including the
+ *
+ *
+ * If you only need to sort by numeric value, and never run range
+ * querying/filtering, you can index using a
+ * 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.
+ * byte[][] of binary field values
+ */
+ public final byte[][] getBinaryValues(String name) {
+ Listnull
+ * if no binary fields with the specified name are available.
+ * There may be non-binary fields with the same name.
+ *
+ * @param name the name of the field.
+ * @return a byte[] containing the binary field value or null
+ */
+ public final byte[] getBinaryValue(String name) {
+ for (IndexableField field : fields) {
+ if (field.name().equals(name) && ((Field) field).isBinary())
+ return field.binaryValue(null).bytes;
+ }
+ return null;
+ }
+
+ public Integer size() {
+ return fields.size();
+ }
+
+ /** Prints the fields of a document for human consumption. */
+ @Override
+ public final String toString() {
+ StringBuilder buffer = new StringBuilder();
+ buffer.append("Document<");
+ for (int i = 0; i < fields.size(); i++) {
+ IndexableField field = fields.get(i);
+ buffer.append(field.toString());
+ if (i != fields.size()-1)
+ buffer.append(" ");
+ }
+ buffer.append(">");
+ return buffer.toString();
+ }
+}
Index: lucene/src/java/org/apache/lucene/document2/Field.java
===================================================================
--- lucene/src/java/org/apache/lucene/document2/Field.java (revision 0)
+++ lucene/src/java/org/apache/lucene/document2/Field.java (revision 0)
@@ -0,0 +1,373 @@
+package org.apache.lucene.document2;
+
+/**
+ * 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;
+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 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;
+
+ 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");
+ if (value == null)
+ throw new IllegalArgumentException("value cannot be null");
+
+ this.type = type;
+ this.name = name;
+ this.fieldsData = value;
+
+ if (internName) // field names are optionally interned
+ name = StringHelper.intern(name);
+ }
+
+ /**
+ * 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 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;
+ }
+
+ public Number getNumericValue() {
+ return null;
+ }
+
+ /**
+ * fieldName should be loaded.
+ */
+ FieldSelectorResult accept(String fieldName);
+}
Index: lucene/src/java/org/apache/lucene/document2/FieldSelectorResult.java
===================================================================
--- lucene/src/java/org/apache/lucene/document2/FieldSelectorResult.java (revision 0)
+++ lucene/src/java/org/apache/lucene/document2/FieldSelectorResult.java (revision 0)
@@ -0,0 +1,76 @@
+package org.apache.lucene.document2;
+
+/**
+ * Copyright 2004 The Apache Software Foundation
+ *
+ * Licensed 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.
+ */
+
+/**
+ * Provides information about what should be done with this Field
+ *
+ **/
+public enum FieldSelectorResult {
+
+ /**
+ * Load this {@link Field} every time the {@link Document} is loaded, reading in the data as it is encountered.
+ * {@link Document#getField(String)} and {@link Document#getFieldable(String)} should not return null.
+ *
+ * document.add(new NumericField(name).setIntValue(value));
+ *
+ *
+ * For optimal performance, re-use the NumericField and
+ * {@link Document} instance for more than one document:
+ *
+ *
+ * NumericField field = new NumericField(name);
+ * Document document = new Document();
+ * document.add(field);
+ *
+ * for(all documents) {
+ * ...
+ * field.setIntValue(value)
+ * writer.addDocument(document);
+ * ...
+ * }
+ *
+ *
+ * int, long, float
+ * and double 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 int or
+ * long value.
+ * NumericField,
+ * use {@link NumericRangeQuery} or {@link NumericRangeFilter}. To sort
+ * according to a NumericField, use the normal numeric sort types,
+ * eg {@link SortField#INT}. NumericField values can also be loaded
+ * directly from {@link FieldCache}.
+ * NumericField's value is not stored but is indexed
+ * for range filtering and sorting. You can use the
+ * {@link #NumericField(String,Field.Store,boolean)} constructor if you need to
+ * change these defaults.
+ * NumericField 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 NumericField.
+ * NumericField 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.
+ * precisionStep, measured in bits. Smaller
+ * precisionStep 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,Field.Store,boolean)} 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.
+ *
+ * precisionStep configuration, see {@link NumericRangeQuery}.
+ * The format of indexed values is described in {@link NumericUtils}.
+ *
+ * precisionStep of
+ * {@link Integer#MAX_VALUE}. This will minimize disk space consumed.
+ * precisionStep {@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
+ * ???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, NumericField.DEFAULT_TYPE);
+ }
+
+ /**
+ * Creates a field for numeric values using the default
+ * precisionStep {@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
+ * ???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}
+ */
+ public NumericField(String name, FieldType type) {
+ this(name, NumericUtils.PRECISION_STEP_DEFAULT, type);
+ }
+
+ /**
+ * Creates a field for numeric values with the specified
+ * precisionStep. The instance is not yet initialized with a
+ * numeric value, before indexing a document containing this field, set a
+ * value using the various set???Value() methods. This constructor
+ * creates an indexed, but not stored field.
+ *
+ * @param name
+ * the field name
+ * @param precisionStep
+ * the used precision step
+ */
+ public NumericField(String name, int precisionStep) {
+ this(name, precisionStep, NumericField.DEFAULT_TYPE);
+ }
+
+ /**
+ * Creates a field for numeric values with the specified
+ * precisionStep. The instance is not yet initialized with a
+ * numeric value, before indexing a document containing this field, set a
+ * value using the various set???Value() methods.
+ *
+ * @param name
+ * the field name
+ * @param precisionStep
+ * the used precision step
+ * @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}
+ */
+ public NumericField(String name, int precisionStep, FieldType type) {
+ super(name, type);
+ this.precisionStep = precisionStep;
+ }
+
+ /** Returns a {@link NumericTokenStream} for indexing the numeric value. */
+ public TokenStream tokenStreamValue() {
+ if (!indexed()) return null;
+ if (numericTS == null) {
+ // 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 dataType != null;
+ final Number val = (Number) fieldsData;
+ switch (dataType) {
+ case INT:
+ numericTS.setIntValue(val.intValue());
+ break;
+ case LONG:
+ numericTS.setLongValue(val.longValue());
+ break;
+ case FLOAT:
+ numericTS.setFloatValue(val.floatValue());
+ break;
+ case DOUBLE:
+ numericTS.setDoubleValue(val.doubleValue());
+ break;
+ default:
+ assert false : "Should never get here";
+ }
+ }
+ }
+ return numericTS;
+ }
+
+ /** Returns always null 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() {
+ return (fieldsData == null) ? null : fieldsData.toString();
+ }
+
+ /**
+ * Returns the current numeric value as a subclass of {@link Number},
+ * null if not yet initialized.
+ */
+ public Number getNumericValue() {
+ return (Number) fieldsData;
+ }
+
+ /** Returns the precision step. */
+ public int getPrecisionStep() {
+ return precisionStep;
+ }
+
+ /**
+ * Returns the data type of the current value, {@code null} if not yet set.
+ *
+ * @since 3.2
+ */
+ public DataType getNumericDataType() {
+ return dataType;
+ }
+
+ public boolean isNumeric() {
+ return true;
+ }
+
+ /**
+ * Initializes the field with the supplied long value.
+ *
+ * @param value
+ * the numeric value
+ * @return this instance, because of this you can use it the following way:
+ * document.add(new NumericField(name, precisionStep).setLongValue(value))
+ */
+ public NumericField setLongValue(final long value) {
+ if (numericTS != null) numericTS.setLongValue(value);
+ fieldsData = Long.valueOf(value);
+ dataType = DataType.LONG;
+ return this;
+ }
+
+ /**
+ * Initializes the field with the supplied int value.
+ *
+ * @param value
+ * the numeric value
+ * @return this instance, because of this you can use it the following way:
+ * document.add(new NumericField(name, precisionStep).setIntValue(value))
+ */
+ public NumericField setIntValue(final int value) {
+ if (numericTS != null) numericTS.setIntValue(value);
+ fieldsData = Integer.valueOf(value);
+ dataType = DataType.INT;
+ return this;
+ }
+
+ /**
+ * Initializes the field with the supplied double value.
+ *
+ * @param value
+ * the numeric value
+ * @return this instance, because of this you can use it the following way:
+ * document.add(new NumericField(name, precisionStep).setDoubleValue(value))
+ */
+ public NumericField setDoubleValue(final double value) {
+ if (numericTS != null) numericTS.setDoubleValue(value);
+ fieldsData = Double.valueOf(value);
+ dataType = DataType.DOUBLE;
+ return this;
+ }
+
+ /**
+ * Initializes the field with the supplied float value.
+ *
+ * @param value
+ * the numeric value
+ * @return this instance, because of this you can use it the following way:
+ * document.add(new NumericField(name, precisionStep).setFloatValue(value))
+ */
+ public NumericField setFloatValue(final float value) {
+ if (numericTS != null) numericTS.setFloatValue(value);
+ fieldsData = Float.valueOf(value);
+ dataType = DataType.FLOAT;
+ return this;
+ }
+
+}
Index: lucene/src/java/org/apache/lucene/document2/StringField.java
===================================================================
--- lucene/src/java/org/apache/lucene/document2/StringField.java (revision 0)
+++ lucene/src/java/org/apache/lucene/document2/StringField.java (revision 0)
@@ -0,0 +1,46 @@
+package org.apache.lucene.document2;
+
+/**
+ * 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 DEFAULT_TYPE = new FieldType();
+ static {
+ DEFAULT_TYPE.setIndexed(true);
+ DEFAULT_TYPE.setOmitNorms(true);
+ DEFAULT_TYPE.setOmitTermFreqAndPositions(true);
+ DEFAULT_TYPE.freeze();
+ }
+
+ public StringField(String name, boolean internName, String value) {
+ super(name, StringField.DEFAULT_TYPE, value);
+ }
+
+ public StringField(String name, String value) {
+ this(name, true, value);
+ }
+
+ public String stringValue() {
+ return (fieldsData == null) ? null : fieldsData.toString();
+ }
+
+ public boolean isNumeric() {
+ return false;
+ }
+}
Index: lucene/src/java/org/apache/lucene/document2/TextField.java
===================================================================
--- lucene/src/java/org/apache/lucene/document2/TextField.java (revision 0)
+++ lucene/src/java/org/apache/lucene/document2/TextField.java (revision 0)
@@ -0,0 +1,48 @@
+package org.apache.lucene.document2;
+
+/**
+ * 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 DEFAULT_TYPE = new FieldType();
+ static {
+ DEFAULT_TYPE.setIndexed(true);
+ DEFAULT_TYPE.setTokenized(true);
+ DEFAULT_TYPE.freeze();
+ }
+
+ public TextField(String name, Reader reader) {
+ super(name, TextField.DEFAULT_TYPE, reader);
+ }
+
+ public TextField(String name, String value) {
+ super(name, TextField.DEFAULT_TYPE, value);
+ }
+
+ public TextField(String name, TokenStream stream) {
+ super(name, TextField.DEFAULT_TYPE, stream);
+ }
+
+ public boolean isNumeric() {
+ return false;
+ }
+}
Index: lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java
===================================================================
--- lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (revision 1134546)
+++ lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (working copy)
@@ -40,6 +40,7 @@
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.Field.TermVector;
+import org.apache.lucene.document2.FieldType;
import org.apache.lucene.index.*;
import org.apache.lucene.index.codecs.Codec;
import org.apache.lucene.index.codecs.CodecProvider;
@@ -1072,7 +1073,24 @@
public static Field newField(String name, String value, Store store, Index index) {
return newField(random, name, value, store, index);
}
+
+ public static org.apache.lucene.document2.Field newField(String name, String value, FieldType type) {
+ return newField(random, name, value, type);
+ }
+ public static org.apache.lucene.document2.Field newField(Random random, String name, String value, FieldType type) {
+ if (usually(random)) {
+ // most of the time, don't modify the params
+ return new org.apache.lucene.document2.Field(name, type, value);
+ }
+
+ if (!type.stored() && random.nextBoolean()) {
+ type.setStored(true); // randomly store it
+ }
+
+ return new org.apache.lucene.document2.Field(name, type, value);
+ }
+
/**
* Returns a new Field instance. Use this when the test does not
* care about some specific field settings (most tests)
Index: lucene/src/test/org/apache/lucene/TestDemo.java
===================================================================
--- lucene/src/test/org/apache/lucene/TestDemo.java (revision 1134546)
+++ lucene/src/test/org/apache/lucene/TestDemo.java (working copy)
@@ -21,8 +21,9 @@
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.MockAnalyzer;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.Field;
+import org.apache.lucene.document2.Document;
+import org.apache.lucene.document2.FieldType;
+import org.apache.lucene.document2.TextField;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.RandomIndexWriter;
import org.apache.lucene.queryParser.ParseException;
@@ -54,8 +55,9 @@
Document doc = new Document();
String longTerm = "longtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongterm";
String text = "This is the text to be indexed. " + longTerm;
- doc.add(newField("fieldname", text, Field.Store.YES,
- Field.Index.ANALYZED));
+ FieldType textType = new FieldType(TextField.DEFAULT_TYPE);
+ textType.setStored(true);
+ doc.add(newField("fieldname", text, textType));
iwriter.addDocument(doc);
iwriter.close();
@@ -70,7 +72,7 @@
assertEquals(1, hits.totalHits);
// Iterate through the results:
for (int i = 0; i < hits.scoreDocs.length; i++) {
- Document hitDoc = isearcher.doc(hits.scoreDocs[i].doc);
+ org.apache.lucene.document.Document hitDoc = isearcher.doc(hits.scoreDocs[i].doc);
assertEquals(text, hitDoc.get("fieldname"));
}