Field.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 IndexWriter = Lucene.Net.Index.IndexWriter;
using StringHelper = Lucene.Net.Util.StringHelper;

namespace Lucene.Net.Documents
{
    
    
    [Serializable]
    public sealed class Field:AbstractField, IFieldable
    {
        public enum Store
        {
            YES,

            NO
        }
        

        public enum Index
        {
            NO,
            
            ANALYZED,
            
            NOT_ANALYZED,
            
            NOT_ANALYZED_NO_NORMS,
            
            ANALYZED_NO_NORMS,
        }
        
        public enum TermVector
        {
            NO,
            
            YES,
            
            WITH_POSITIONS,
            
            WITH_OFFSETS,
            
            WITH_POSITIONS_OFFSETS,
        }


        public override string StringValue
        {
            get { return fieldsData is System.String ? (System.String) fieldsData : null; }
        }

        public override TextReader ReaderValue
        {
            get { return fieldsData is System.IO.TextReader ? (System.IO.TextReader) fieldsData : null; }
        }

        public override TokenStream TokenStreamValue
        {
            get { return tokenStream; }
        }


        public void  SetValue(System.String value)
        {
            if (internalIsBinary)
            {
                throw new System.ArgumentException("cannot set a String value on a binary field");
            }
            fieldsData = value;
        }
        
        public void  SetValue(System.IO.TextReader value)
        {
            if (internalIsBinary)
            {
                throw new System.ArgumentException("cannot set a Reader value on a binary field");
            }
            if (internalIsStored)
            {
                throw new System.ArgumentException("cannot set a Reader value on a stored field");
            }
            fieldsData = value;
        }
        
        public void  SetValue(byte[] value)
        {
            if (!internalIsBinary)
            {
                throw new System.ArgumentException("cannot set a byte[] value on a non-binary field");
            }
            fieldsData = value;
            internalBinaryLength = value.Length;
            internalbinaryOffset = 0;
        }
        
        public void  SetValue(byte[] value, int offset, int length)
        {
            if (!internalIsBinary)
            {
                throw new System.ArgumentException("cannot set a byte[] value on a non-binary field");
            }
            fieldsData = value;
            internalBinaryLength = length;
            internalbinaryOffset = offset;
        }
        
        public void  SetTokenStream(TokenStream tokenStream)
        {
            this.internalIsIndexed = true;
            this.internalIsTokenized = true;
            this.tokenStream = tokenStream;
        }
        
        public Field(System.String name, System.String value, Store store, Index index)
            : this(name, value, store, index, TermVector.NO)
        {
        }
        
        public Field(System.String name, System.String value, Store store, Index index, TermVector termVector)
            : this(name, true, value, store, index, termVector)
        {
        }
        
        public Field(System.String name, bool internName, System.String value, Store store, Index index, TermVector termVector)
        {
            if (name == null)
                throw new System.NullReferenceException("name cannot be null");
            if (value == null)
                throw new System.NullReferenceException("value cannot be null");
            if (name.Length == 0 && value.Length == 0)
                throw new System.ArgumentException("name and value cannot both be empty");
            if (index == Index.NO && store == Store.NO)
                throw new System.ArgumentException("it doesn't make sense to have a field that " + "is neither indexed nor stored");
            if (index == Index.NO && termVector != TermVector.NO)
                throw new System.ArgumentException("cannot store term vector information " + "for a field that is not indexed");
            
            if (internName)
            // field names are optionally interned
                name = StringHelper.Intern(name);
            
            this.internalName = name;
            
            this.fieldsData = value;

            this.internalIsStored = store.IsStored();

            this.internalIsIndexed = index.IsIndexed();
            this.internalIsTokenized = index.IsAnalyzed();
            this.internalOmitNorms = index.OmitNorms();

            if (index == Index.NO)
            {
                this.internalOmitTermFreqAndPositions = false;
            }
            
            this.internalIsBinary = false;
            
            SetStoreTermVector(termVector);
        }
        
        public Field(System.String name, System.IO.TextReader reader):this(name, reader, TermVector.NO)
        {
        }
        
        public Field(System.String name, System.IO.TextReader reader, TermVector termVector)
        {
            if (name == null)
                throw new System.NullReferenceException("name cannot be null");
            if (reader == null)
                throw new System.NullReferenceException("reader cannot be null");
            
            this.internalName = StringHelper.Intern(name); // field names are interned
            this.fieldsData = reader;
            
            this.internalIsStored = false;
            
            this.internalIsIndexed = true;
            this.internalIsTokenized = true;
            
            this.internalIsBinary = false;
            
            SetStoreTermVector(termVector);
        }
        
        public Field(System.String name, TokenStream tokenStream):this(name, tokenStream, TermVector.NO)
        {
        }
        
        public Field(System.String name, TokenStream tokenStream, TermVector termVector)
        {
            if (name == null)
                throw new System.NullReferenceException("name cannot be null");
            if (tokenStream == null)
                throw new System.NullReferenceException("tokenStream cannot be null");
            
            this.internalName = StringHelper.Intern(name); // field names are interned
            this.fieldsData = null;
            this.tokenStream = tokenStream;
            
            this.internalIsStored = false;
            
            this.internalIsIndexed = true;
            this.internalIsTokenized = true;
            
            this.internalIsBinary = false;
            
            SetStoreTermVector(termVector);
        }
        
        
        public Field(System.String name, byte[] value_Renamed, Store store):this(name, value_Renamed, 0, value_Renamed.Length, store)
        {
        }
        
        public Field(System.String name, byte[] value_Renamed, int offset, int length, Store store)
        {
            
            if (name == null)
                throw new System.ArgumentException("name cannot be null");
            if (value_Renamed == null)
                throw new System.ArgumentException("value cannot be null");
            
            this.internalName = StringHelper.Intern(name); // field names are interned
            fieldsData = value_Renamed;
            
            if (store == Store.NO)
                throw new System.ArgumentException("binary values can't be unstored");

            internalIsStored = store.IsStored();
            internalIsIndexed = false;
            internalIsTokenized = false;
            internalOmitTermFreqAndPositions = false;
            internalOmitNorms = true;
            
            internalIsBinary = true;
            internalBinaryLength = length;
            internalbinaryOffset = offset;
            
            SetStoreTermVector(TermVector.NO);
        }
    }

    public static class FieldExtensions
    {
        public static bool IsStored(this Field.Store store)
        {
            switch(store)
            {
                case Field.Store.YES:
                    return true;
                case Field.Store.NO:
                    return false;
                default:
                    throw new ArgumentOutOfRangeException("store", "Invalid value for Field.Store");
            }
        }

        public static bool IsIndexed(this Field.Index index)
        {
            switch(index)
            {
                case Field.Index.NO:
                    return false;
                case Field.Index.ANALYZED:
                case Field.Index.NOT_ANALYZED:
                case Field.Index.NOT_ANALYZED_NO_NORMS:
                case Field.Index.ANALYZED_NO_NORMS:
                    return true;
                default:
                    throw new ArgumentOutOfRangeException("index", "Invalid value for Field.Index");
            }
        }

        public static bool IsAnalyzed(this Field.Index index)
        {
            switch (index)
            {
                case Field.Index.NO:
                case Field.Index.NOT_ANALYZED:
                case Field.Index.NOT_ANALYZED_NO_NORMS:
                    return false;
                case Field.Index.ANALYZED:
                case Field.Index.ANALYZED_NO_NORMS:
                    return true;
                default:
                    throw new ArgumentOutOfRangeException("index", "Invalid value for Field.Index");
            }
        }

        public static bool OmitNorms(this Field.Index index)
        {
            switch (index)
            {
                case Field.Index.ANALYZED:
                case Field.Index.NOT_ANALYZED:
                    return false;
                case Field.Index.NO:
                case Field.Index.NOT_ANALYZED_NO_NORMS:
                case Field.Index.ANALYZED_NO_NORMS:
                    return true;
                default:
                    throw new ArgumentOutOfRangeException("index", "Invalid value for Field.Index");
            }
        }

        public static bool IsStored(this Field.TermVector tv)
        {
            switch(tv)
            {
                case Field.TermVector.NO:
                    return false;
                case Field.TermVector.YES:
                case Field.TermVector.WITH_OFFSETS:
                case Field.TermVector.WITH_POSITIONS:
                case Field.TermVector.WITH_POSITIONS_OFFSETS:
                    return true;
                default:
                    throw new ArgumentOutOfRangeException("tv", "Invalid value for Field.TermVector");
            }
        }

        public static bool WithPositions(this Field.TermVector tv)
        {
            switch (tv)
            {
                case Field.TermVector.NO:
                case Field.TermVector.YES:
                case Field.TermVector.WITH_OFFSETS:
                    return false;
                case Field.TermVector.WITH_POSITIONS:
                case Field.TermVector.WITH_POSITIONS_OFFSETS:
                    return true;
                default:
                    throw new ArgumentOutOfRangeException("tv", "Invalid value for Field.TermVector");
            }
        }

        public static bool WithOffsets(this Field.TermVector tv)
        {
            switch (tv)
            {
                case Field.TermVector.NO:
                case Field.TermVector.YES:
                case Field.TermVector.WITH_POSITIONS:
                    return false;
                case Field.TermVector.WITH_OFFSETS:
                case Field.TermVector.WITH_POSITIONS_OFFSETS:
                    return true;
                default:
                    throw new ArgumentOutOfRangeException("tv", "Invalid value for Field.TermVector");
            }
        }

        public static Field.Index ToIndex(bool indexed, bool analyed)
        {
            return ToIndex(indexed, analyed, false);
        }

        public static Field.Index ToIndex(bool indexed, bool analyzed, bool omitNorms)
        {

            // If it is not indexed nothing else matters
            if (!indexed)
            {
                return Field.Index.NO;
            }

            // typical, non-expert
            if (!omitNorms)
            {
                if (analyzed)
                {
                    return Field.Index.ANALYZED;
                }
                return Field.Index.NOT_ANALYZED;
            }

            // Expert: Norms omitted
            if (analyzed)
            {
                return Field.Index.ANALYZED_NO_NORMS;
            }
            return Field.Index.NOT_ANALYZED_NO_NORMS;
        }

        public static Field.TermVector ToTermVector(bool stored, bool withOffsets, bool withPositions)
        {
            // If it is not stored, nothing else matters.
            if (!stored)
            {
                return Field.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;
        }
    }
}