/*
* 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.
*/
using System;
using System.IO;
using TokenStream = Lucene.Net.Analysis.TokenStream;
using FieldInvertState = Lucene.Net.Index.FieldInvertState;
namespace Lucene.Net.Documents
{
/// Synonymous with .
///
/// WARNING: This interface may change within minor versions, despite Lucene's backward compatibility requirements.
/// This means new methods may be added from version to version. This change only affects the Fieldable API; other backwards
/// compatibility promises remain intact. For example, Lucene can still
/// read and write indices created within the same major version.
///
///
///
///
public interface IFieldable
{
/// Gets or sets the boost factor for hits for this field. This value will be
/// multiplied into the score of all hits on this this field of this
/// document.
///
/// The boost is multiplied by 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
/// method, the boost value is multiplied
/// by the
/// and then rounded by before it is stored in the
/// index. One should attempt to ensure that this product does not overflow
/// the range of that encoding.
///
/// The default value is 1.0.
///
/// Note: this value is not stored directly with the document in the index.
/// Documents returned from and
/// may thus not have the same value present as when
/// this field was indexed.
///
///
///
///
///
///
///
///
float Boost { get; set; }
/// Returns the name of the field as an interned string.
/// For example "date", "title", "body", ...
///
string Name { get; }
/// The value of the field as a String, or null.
///
/// For indexing, if isStored()==true, the stringValue() will be used as the stored field value
/// unless isBinary()==true, in which case GetBinaryValue() will be used.
///
/// If isIndexed()==true and isTokenized()==false, this String value will be indexed as a single token.
/// If isIndexed()==true and isTokenized()==true, then tokenStreamValue() will be used to generate indexed tokens if not null,
/// else readerValue() will be used to generate indexed tokens if not null, else stringValue() will be used to generate tokens.
///
string StringValue { get; }
/// The value of the field as a Reader, which can be used at index time to generate indexed tokens.
///
///
TextReader ReaderValue { get; }
/// The TokenStream for this field to be used when indexing, or null.
///
///
TokenStream TokenStreamValue { get; }
/// True if the value of the field is to be stored in the index for return
/// with search hits.
///
bool IsStored { get; }
/// True if the value of the field is to be indexed, so that it may be
/// searched on.
///
bool IsIndexed { get; }
/// True if the value of the field should be tokenized as text prior to
/// indexing. Un-tokenized fields are indexed as a single word and may not be
/// Reader-valued.
///
bool IsTokenized { get; }
/// True if the term or terms used to index this field are stored as a term
/// vector, available from .
/// These methods do not provide access to the original content of the field,
/// only to terms used to index it. If the original content must be
/// preserved, use the stored attribute instead.
///
///
///
///
bool IsTermVectorStored { get; }
/// True if terms are stored as term vector together with their offsets
/// (start and end positon in source text).
///
bool IsStoreOffsetWithTermVector { get; }
/// True if terms are stored as term vector together with their token positions.
bool IsStorePositionWithTermVector { get; }
/// True if the value of the field is stored as binary
bool IsBinary { get; }
///
/// True if norms are omitted for this indexed field.
///
/// Expert:
/// If set, omit normalization factors associated with this indexed field.
/// This effectively disables indexing boosts and length normalization for this field.
///
///
bool OmitNorms { get; set; }
/// Indicates whether a Field is Lazy or not. The semantics of Lazy loading are such that if a Field is lazily loaded, retrieving
/// it's values via or is only valid as long as the that
/// retrieved the is still open.
///
///
/// true if this field can be loaded lazily
bool IsLazy { get; }
/// Returns offset into byte[] segment that is used as value, if Field is not binary
/// returned value is undefined
///
/// index of the first character in byte[] segment that represents this Field value
int BinaryOffset { get; }
/// Returns length of byte[] segment that is used as value, if Field is not binary
/// returned value is undefined
///
/// length of byte[] segment that represents this Field value
int BinaryLength { get; }
/// Return the raw byte[] for the binary field. Note that
/// you must also call and
/// to know which range of bytes in this
/// returned array belong to the field.
///
/// reference to the Field value as byte[].
byte[] GetBinaryValue();
/// Return the raw byte[] for the binary field. Note that
/// you must also call and
/// to know which range of bytes in this
/// returned array belong to the field.
/// About reuse: if you pass in the result byte[] and it is
/// used, likely the underlying implementation will hold
/// onto this byte[] and return it in future calls to
/// or .
/// So if you subsequently re-use the same byte[] elsewhere
/// it will alter this Fieldable's value.
///
/// User defined buffer that will be used if
/// possible. If this is null or not large enough, a new
/// buffer is allocated
///
/// reference to the Field value as byte[].
///
byte[] GetBinaryValue(byte[] result);
/// Expert:
///
/// If set, omit term freq, positions and payloads from
/// postings for this field.
///
///
/// NOTE: While this option reduces storage space
/// required in the index, it also means any query
/// requiring positional information, such as
/// or
///
/// subclasses will silently fail to find results.
///
bool OmitTermFreqAndPositions { set; get; }
}
}