IndexSet.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.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.Xml;
using Lucene.Net.Distributed;
//using Lucene.Net.Distributed.Search;
using Lucene.Net.Distributed.Configuration;
using Documents = Lucene.Net.Documents;
using Lucene.Net.Analysis;
using Lucene.Net.Analysis.Standard;
using Lucene.Net.Index;

namespace Lucene.Net.Distributed.Indexing
{
    public class IndexSet
    {
        #region Variables
        private int _intId = -1;
        private string _strLocalPath;
        private string _strIdColumn;
        private int _intBottomId;
        private int _intTopId;
        private CurrentIndex _oCurrentIndex;
        private IndexAction _eIndexAction=IndexAction.NoAction;
        private AnalyzerType _eAnalyzerType=AnalyzerType.StandardAnalyzer;
        private Hashtable _htDocuments = new Hashtable();
        private Hashtable _htIndexDocuments = new Hashtable();
        private List<string> _alFileSystemDocuments = new List<string>();
        #endregion

        #region Constructors





        public IndexSet(XmlNode node)
        {
            this.LoadValues(node);
        }

        #endregion

        #region Internal voids





        internal void LoadValues(XmlNode node)
        {
            XmlAttributeCollection attributeCollection = node.Attributes;
            try
            {
                this._intId = Convert.ToInt32(attributeCollection["id"].Value);
            }
            catch (Exception)
            {
                throw new ConfigurationErrorsException("IndexSet id invalid: " + Environment.NewLine + node.OuterXml);
            }

            try
            {
                this._eIndexAction = (IndexAction)Enum.Parse(typeof(IndexAction), attributeCollection["action"].Value);
            }
            catch (Exception)
            {
                throw new ConfigurationErrorsException("IndexSet "+this._intId.ToString()+" IndexAction invalid: " + Environment.NewLine + node.OuterXml);
            }

            try
            {
                if (attributeCollection["analyzer"] != null)
                    this._eAnalyzerType = (AnalyzerType)Enum.Parse(typeof(AnalyzerType), attributeCollection["analyzer"].Value);
            }
            catch (Exception)
            {
                throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " analyzer invalid: " + Environment.NewLine + node.OuterXml);
            }

            if (node.ChildNodes.Count==0)
                throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " configuration missing " + Environment.NewLine + node.OuterXml);

            foreach (XmlNode c in node.ChildNodes)
            {
                if (!c.HasChildNodes)
                {
                    switch (c.Attributes["key"].Value.ToLower())
                    {
                        case "localpath":
                            this._strLocalPath = c.Attributes["value"].Value;
                            break;
                        case "idcolumn":
                            this._strIdColumn = c.Attributes["value"].Value;
                            break;
                        case "bottomid":
                            try
                            {
                                this._intBottomId = Convert.ToInt32(c.Attributes["value"].Value);
                            }
                            catch (Exception)
                            {
                                throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " bottomid invalid: " + Environment.NewLine + node.OuterXml);
                            }
                            break;
                        case "topid":
                            try
                            {
                                this._intTopId = Convert.ToInt32(c.Attributes["value"].Value);
                            }
                            catch (Exception)
                            {
                                throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " topid invalid: " + Environment.NewLine + node.OuterXml);
                            }
                            break;
                    }
                }
                else
                {
                    switch(c.Name.ToLower())
                    {
                        case "copy":
                            if (this._strLocalPath!=null)
                                LoadCopy(c,this._strLocalPath);
                            else
                                LoadCopy(c,node);
                            break;
                    }
                }
            }
            this.CheckValidSet(node);

        }

        internal void LoadCopy(XmlNode node, string localpath)
        {
            this._oCurrentIndex = new CurrentIndex(node,localpath);
        }

        internal void LoadCopy(XmlNode node, XmlNode masternode)
        {
            foreach (XmlNode c in node.ChildNodes)
            {
                if (c.Attributes["key"] != null)
                {
                    switch (c.Attributes["key"].Value.ToLower())
                    {
                        case "localpath":
                            this.LoadCopy(node, c.Attributes["value"].Value);
                            break;
                    }
                }
            }
        }

        private void CheckValidSet(XmlNode node)
        {
            if (this._strLocalPath==null) throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " LocalPath invalid: " + Environment.NewLine + node.OuterXml);
            if (this._eIndexAction==IndexAction.NoAction) throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " IndexAction undefined: " + Environment.NewLine + node.OuterXml);
            if (this._strIdColumn==null) throw new ConfigurationErrorsException("IndexSet " + this._intId.ToString() + " IdColumn undefined: " + Environment.NewLine + node.OuterXml);
        }

        #endregion

        #region Properties



        public int Id
        {
            get {return this._intId;}
        }

        public IndexAction IndexAction
        {
            get {return this._eIndexAction;}
        }

        public AnalyzerType AnalyzerType
        {
            get {return this._eAnalyzerType;}
        }

        public Analyzer Analzyer
        {
            get {return CurrentIndex.GetAnalyzer(this._eAnalyzerType);}
        }

        public string LocalPath
        {
            get {return this._strLocalPath;}
        }

        public string IdColumn
        {
            get {return this._strIdColumn;}
        }

        public int BottomId
        {
            get {return this._intBottomId;}
        }

        public int TopId
        {
            get {return this._intTopId;}
        }

        public CurrentIndex CurrentIndex
        {
            get {return this._oCurrentIndex;}
        }

        public List<string> FileSystemDocuments
        {
            get { return this._alFileSystemDocuments; }
        }

        public Hashtable IndexDocuments
        {
            get { return this._htIndexDocuments; }
        }

        public Hashtable Documents
        {
            get
            {
                this._htDocuments.Clear();
                foreach (DictionaryEntry de in this._htIndexDocuments)
                {
                    IndexDocument iDoc = (IndexDocument)de.Value;
                    if (!(iDoc is DeleteIndexDocument))
                        this._htDocuments.Add(iDoc.Document, iDoc.GetAnalyzer());
                }
                return this._htDocuments;
            }
        }
        #endregion

        #region Methods





        public NameValueCollection GetDeletionCollection()
        {
            NameValueCollection nvc = new NameValueCollection(this._htDocuments.Count);
            foreach(DictionaryEntry de in this._htIndexDocuments)
                nvc.Add(this.IdColumn, ((IndexDocument)de.Value).RecordId.ToString());
            return nvc;
        }

        public void Reset()
        {
            this._htIndexDocuments.Clear();
            this._htDocuments.Clear();
        }

        public void Optimize()
        {
            if (IndexReader.IndexExists(this._strLocalPath))
            {
                IndexWriter idxWriter = new IndexWriter(this._strLocalPath, this.Analzyer, false);
                idxWriter.SetMergeFactor(2);
                idxWriter.Optimize();
                idxWriter.Close();
            }
        }

        public bool ContainsId(int recordId)
        {
            return (this._intTopId >= recordId && this._intBottomId <= recordId);
        }
        #endregion
    }
}