C# IndexReader.Directory方法代码示例

		public SuggestionQueryIndexExtension(
			string key,
			IndexReader reader,
			StringDistance distance, 
			string field, 
			float accuracy)
		{
			this.key = key;
			this.field = field;
			
			if(reader.Directory() is RAMDirectory)
			{
				directory = new RAMDirectory();
			}
			else
			{
				directory = FSDirectory.Open(new DirectoryInfo(key));
			}

			this.spellChecker = new SpellChecker.Net.Search.Spell.SpellChecker(directory, distance);
			this.spellChecker.SetAccuracy(accuracy);
		}

        private void CloseInternalReader(bool trace, IndexReader subReader, bool finalClose)
        {
            ReaderData readerData;
            // TODO: can we avoid the lock?
            lock (semaphoreIndexReaderLock)
            {
                readerData = searchIndexReaderSemaphores[subReader];
            }

            if (readerData == null)
            {
                log.Error("Trying to close a Lucene IndexReader not present: " + subReader.Directory());
                // TODO: Should we try to close?
                return;
            }

            // Acquire the locks in the same order as everywhere else
            object directoryProviderLock = perDirectoryProviderManipulationLocks[readerData.Provider];
            bool closeReader = false;
            lock (directoryProviderLock)
            {
                IndexReader reader;
                bool isActive = activeSearchIndexReaders.TryGetValue(readerData.Provider, out reader)
                    && reader == subReader;
                if (trace) log.Info("IndexReader not active: " + subReader);
                lock (semaphoreIndexReaderLock)
                {
                    readerData = searchIndexReaderSemaphores[subReader];
                    if (readerData == null)
                    {
                        log.Error("Trying to close a Lucene IndexReader not present: " + subReader.Directory());
                        // TODO: Should we try to close?
                        return;
                    }

                    //final close, the semaphore should be at 0 already
                    if (!finalClose)
                    {
                        readerData.Semaphore--;
                        if (trace)
                            log.Info("Semaphore decreased to: " + readerData.Semaphore + " for " + subReader);
                    }

                    if (readerData.Semaphore < 0)
                        log.Error("Semaphore negative: " + subReader.Directory());

                    if (!isActive && readerData.Semaphore == 0)
                    {
                        searchIndexReaderSemaphores.Remove(subReader);
                        closeReader = true;
                    }
                    else
                        closeReader = false;
                }
            }

            if (closeReader)
            {
                if (trace) log.Info("Closing IndexReader: " + subReader);
                try
                {
                    subReader.Close();
                }
                catch (IOException e)
                {
                    log.Warn("Unable to close Lucene IndexReader", e);
                }
            }
        }

 /// <summary> <p>Construct a FilterIndexReader based on the specified base reader.
 /// Directory locking for delete, undeleteAll, and setNorm operations is
 /// left to the base reader.</p>
 /// <p>Note that base reader is closed if this FilterIndexReader is closed.</p>
 /// </summary>
 /// <param name="in">specified base reader.
 /// </param>
 public FilterIndexReader(IndexReader in_Renamed)
     : base(in_Renamed.Directory())
 {
     this.in_Renamed = in_Renamed;
 }

        /// <summary>
        /// Gets the similar words.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="fieldName">Name of the field.</param>
        /// <param name="word">The word.</param>
        /// <returns></returns>
        private static string[] SuggestSimilar(IndexReader reader, string fieldName, string word)
        {
            var spell = new SpellChecker.Net.Search.Spell.SpellChecker(reader.Directory());
            spell.IndexDictionary(new LuceneDictionary(reader, fieldName));
            var similarWords = spell.SuggestSimilar(word, 2);

            // now make sure to close the spell checker
            spell.Close();

            return similarWords;
        }

        public override DocIdSet GetDocIdSet(IndexReader reader)
        {
            DocIdSet docs = null;

            // TODO: override by SinSay
            var cache = IdSetCache.GetCache(reader.Directory().ToString(), this.fieldName);
            if (cache != null)
            {
                return cache.Cache;
            }

            if (processingMode == PM_FAST_INVALIDATION)
            {
                docs = FastBits(reader);
            }
            else
            {
                docs = CorrectBits(reader);
            }

            return docs;
        }