AbstractField.cs

Go to the documentation of this file.

/* 
 * 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 StringHelper = Lucene.Net.Util.StringHelper;
using PhraseQuery = Lucene.Net.Search.PhraseQuery;
using SpanQuery = Lucene.Net.Search.Spans.SpanQuery;

namespace Lucene.Net.Documents
{
    [Serializable]
    public abstract class AbstractField : IFieldable
    {
        
        protected internal System.String internalName = "body";
        protected internal bool storeTermVector = false;
        protected internal bool storeOffsetWithTermVector = false;
        protected internal bool storePositionWithTermVector = false;
        protected internal bool internalOmitNorms = false;
        protected internal bool internalIsStored = false;
        protected internal bool internalIsIndexed = true;
        protected internal bool internalIsTokenized = true;
        protected internal bool internalIsBinary = false;
        protected internal bool lazy = false;
        protected internal bool internalOmitTermFreqAndPositions = false;
        protected internal float internalBoost = 1.0f;
        // the data object for all different kind of field values
        protected internal System.Object fieldsData = null;
        // pre-analyzed tokenStream for indexed fields
        protected internal TokenStream tokenStream;
        // length/offset for all primitive types
        protected internal int internalBinaryLength;
        protected internal int internalbinaryOffset;
        
        protected internal AbstractField()
        {
        }
        
        protected internal AbstractField(System.String name, Field.Store store, Field.Index index, Field.TermVector termVector)
        {
            if (name == null)
                throw new System.NullReferenceException("name cannot be null");
            this.internalName = StringHelper.Intern(name); // field names are interned

            this.internalIsStored = store.IsStored();
            this.internalIsIndexed = index.IsIndexed();
            this.internalIsTokenized = index.IsAnalyzed();
            this.internalOmitNorms = index.OmitNorms();
            
            this.internalIsBinary = false;
            
            SetStoreTermVector(termVector);
        }

        public virtual float Boost
        {
            get { return internalBoost; }
            set { this.internalBoost = value; }
        }

        public virtual string Name
        {
            get { return internalName; }
        }

        protected internal virtual void  SetStoreTermVector(Field.TermVector termVector)
        {
            this.storeTermVector = termVector.IsStored();
            this.storePositionWithTermVector = termVector.WithPositions();
            this.storeOffsetWithTermVector = termVector.WithOffsets();
        }

        public bool IsStored
        {
            get { return internalIsStored; }
        }

        public bool IsIndexed
        {
            get { return internalIsIndexed; }
        }

        public bool IsTokenized
        {
            get { return internalIsTokenized; }
        }

        public bool IsTermVectorStored
        {
            get { return storeTermVector; }
        }

        public virtual bool IsStoreOffsetWithTermVector
        {
            get { return storeOffsetWithTermVector; }
        }

        public virtual bool IsStorePositionWithTermVector
        {
            get { return storePositionWithTermVector; }
        }

        public bool IsBinary
        {
            get { return internalIsBinary; }
        }


        public virtual byte[] GetBinaryValue()
        {
            return GetBinaryValue(null);
        }

        public virtual byte[] GetBinaryValue(byte[] result)
        {
            if (internalIsBinary || fieldsData is byte[])
                return (byte[]) fieldsData;
            else
                return null;
        }

        public virtual int BinaryLength
        {
            get
            {
                if (internalIsBinary)
                {
                    return internalBinaryLength;
                }
                return fieldsData is byte[] ? ((byte[]) fieldsData).Length : 0;
            }
        }

        public virtual int BinaryOffset
        {
            get { return internalbinaryOffset; }
        }

        public virtual bool OmitNorms
        {
            get { return internalOmitNorms; }
            set { this.internalOmitNorms = value; }
        }

        public virtual bool OmitTermFreqAndPositions
        {
            set { this.internalOmitTermFreqAndPositions = value; }
            get { return internalOmitTermFreqAndPositions; }
        }

        public virtual bool IsLazy
        {
            get { return lazy; }
        }

        public override System.String ToString()
        {
            System.Text.StringBuilder result = new System.Text.StringBuilder();
            if (internalIsStored)
            {
                result.Append("stored");
            }
            if (internalIsIndexed)
            {
                if (result.Length > 0)
                    result.Append(",");
                result.Append("indexed");
            }
            if (internalIsTokenized)
            {
                if (result.Length > 0)
                    result.Append(",");
                result.Append("tokenized");
            }
            if (storeTermVector)
            {
                if (result.Length > 0)
                    result.Append(",");
                result.Append("termVector");
            }
            if (storeOffsetWithTermVector)
            {
                if (result.Length > 0)
                    result.Append(",");
                result.Append("termVectorOffsets");
            }
            if (storePositionWithTermVector)
            {
                if (result.Length > 0)
                    result.Append(",");
                result.Append("termVectorPosition");
            }
            if (internalIsBinary)
            {
                if (result.Length > 0)
                    result.Append(",");
                result.Append("binary");
            }
            if (internalOmitNorms)
            {
                result.Append(",omitNorms");
            }
            if (internalOmitTermFreqAndPositions)
            {
                result.Append(",omitTermFreqAndPositions");
            }
            if (lazy)
            {
                result.Append(",lazy");
            }
            result.Append('<');
            result.Append(internalName);
            result.Append(':');
            
            if (fieldsData != null && lazy == false)
            {
                result.Append(fieldsData);
            }
            
            result.Append('>');
            return result.ToString();
        }

        public abstract TokenStream TokenStreamValue { get; }
        public abstract TextReader ReaderValue { get; }
        public abstract string StringValue { get; }
    }
}