C# 클래스 Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter

Takes the categories from the given taxonomy directory, and adds the missing ones to this taxonomy. Additionally, it fills the given OrdinalMap with a mapping from the original ordinal to the new ordinal.

Defines the default TaxonomyWriterCache to use in constructors which do not specify one.

The current default is Cl2oTaxonomyWriterCache constructed with the parameters (1024, 0.15f, 3), i.e., the entire taxonomy is cached in memory while building it.

Creates a new instance with a default cache as defined by #defaultTaxonomyWriterCache().

Construct a Taxonomy writer.

Frees used resources as well as closes the underlying IndexWriter, which commits whatever changes made to it to the underlying Directory.

prepare most of the work needed for a two-phase commit. See IndexWriter#prepareCommit.

Replaces the current taxonomy with the given one. This method should generally be called in conjunction with IndexWriter#addIndexes(Directory...) to replace both the taxonomy as well as the search index content.

Rollback changes to the taxonomy writer and closes the instance. Following this method the instance becomes unusable (calling any of its API methods will yield an AlreadyClosedException).

Forcibly unlocks the taxonomy in the named directory.

Caution: this should only be used by failure recovery code, when it is known that no other process nor thread is in fact currently accessing this taxonomy.

This method is unnecessary if your Directory uses a NativeFSLockFactory instead of the default SimpleFSLockFactory. When the "native" lock is used, a lock does not stay behind forever when the process using it dies.

A hook for extending classes to close additional resources that were used. The default implementation closes the IndexReader as well as the TaxonomyWriterCache instances that were used.
NOTE: if you override this method, you should include a super.closeResources() call in your implementation.

Create the IndexWriterConfig that would be used for opening the internal index writer.
Extensions can configure the IndexWriter as they see fit, including setting a Lucene.Net.index.MergeScheduler merge-scheduler, or Lucene.Net.index.IndexDeletionPolicy deletion-policy, different RAM size etc.

NOTE: internal docids of the configured index must not be altered. For that, categories are never deleted from the taxonomy index. In addition, merge policy in effect must not merge none adjacent segments.

Verifies that this instance wasn't closed, or throws AlreadyClosedException if it is.

Look up the given category in the cache and/or the on-disk storage, returning the category's ordinal, or a negative number in case the category does not yet exist in the taxonomy.

Open internal index writer, which contains the taxonomy data.

Extensions may provide their own IndexWriter implementation or instance.
NOTE: the instance this method returns will be closed upon calling to #close().
NOTE: the merge policy in effect must not merge none adjacent segments. See comment in #createIndexWriterConfig(IndexWriterConfig.OpenMode) for the logic behind this.

Note that the methods calling addCategoryDocument() are synchornized, so this method is effectively synchronized as well.

Combine original user data with the taxonomy epoch.

Opens a ReaderManager from the internal IndexWriter.

Add a new category into the index (and the cache), and return its new ordinal.

Actually, we might also need to add some of the category's ancestors before we can add the category itself (while keeping the invariant that a parent is always added to the taxonomy before its child). We do this by recursion.

Reads the commit data from a Directory.