@@ -2400,14 +2400,14 @@
/// be consistent. However, the close will not be complete
/// even though part of it (flushing buffered documents)
/// may have succeeded, so the write lock will still be
- /// held.
+ /// held.
///
/// If you can correct the underlying cause (eg free up
/// some disk space) then you can call close() again.
/// Failing that, if you want to force the write lock to be
/// released (dangerous, because you may then lose buffered
/// docs in the IndexWriter instance) then you can do
- /// something like this:
+ /// something like this:
///
///
/// try {
@@ -2420,11 +2420,11 @@
///
///
/// after which, you must be certain not to use the writer
- /// instance anymore.
+ /// instance anymore.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer, again. See above for details.
+ /// href="#OOME">above for details.
///
///
/// CorruptIndexException if the index is corrupt
@@ -2441,14 +2441,14 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer, again. See above for details.
+ /// href="#OOME">above for details.
///
/// NOTE: it is dangerous to always call
/// close(false), especially when IndexWriter is not open
/// for very long, because this can result in "merge
/// starvation" whereby long merges will never have a
/// chance to finish. This will cause too many segments in
- /// your index over time.
+ /// your index over time.
///
///
/// if true, this call will block
@@ -2790,12 +2790,12 @@
/// may not have been added. Furthermore, it's possible
/// the index will have one segment in non-compound format
/// even when using compound files (when a merge has
- /// partially succeeded).
+ /// partially succeeded).
///
/// This method periodically flushes pending documents
/// to the Directory (see above), and
/// also periodically triggers segment merges in the index
- /// according to the {@link MergePolicy} in use.
+ /// according to the {@link MergePolicy} in use.
///
/// Merges temporarily consume space in the
/// directory. The amount of space required is up to 1X the
@@ -2809,17 +2809,17 @@
///
/// Note that each term in the document can be no longer
/// than 16383 characters, otherwise an
- /// IllegalArgumentException will be thrown.
+ /// IllegalArgumentException will be thrown.
///
/// Note that it's possible to create an invalid Unicode
/// string in java if a UTF16 surrogate pair is malformed.
/// In this case, the invalid characters are silently
/// replaced with the Unicode replacement character
- /// U+FFFD.
+ /// U+FFFD.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// CorruptIndexException if the index is corrupt
@@ -2836,11 +2836,11 @@
///
/// See {@link #AddDocument(Document)} for details on
/// index and IndexWriter state after an Exception, and
- /// flushing/merging temporary free space requirements.
+ /// flushing/merging temporary free space requirements.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// CorruptIndexException if the index is corrupt
@@ -2891,7 +2891,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// the term to identify the documents to be deleted
@@ -2918,7 +2918,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// array of terms to identify the documents
@@ -2945,7 +2945,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// the query to identify the documents to be deleted
@@ -2965,7 +2965,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// array of queries to identify the documents
@@ -2989,7 +2989,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// the term to identify the document(s) to be
@@ -3013,7 +3013,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// the term to identify the document(s) to be
@@ -3145,28 +3145,28 @@
/// It is recommended that this method be called upon completion of indexing. In
/// environments with frequent updates, optimize is best done during low volume times, if at all.
///
- ///
- /// See http://www.gossamer-threads.com/lists/lucene/java-dev/47895 for more discussion.
+ ///
+ /// See http://www.gossamer-threads.com/lists/lucene/java-dev/47895 for more discussion.
///
/// Note that optimize requires 2X the index size free
/// space in your Directory. For example, if your index
/// size is 10 MB then you need 20 MB free for optimize to
- /// complete.
+ /// complete.
///
/// If some but not all readers re-open while an
/// optimize is underway, this will cause > 2X temporary
/// space to be consumed as those new readers will then
/// hold open the partially optimized segments at that
/// time. It is best not to re-open readers while optimize
- /// is running.
+ /// is running.
///
/// The actual temporary usage could be much less than
- /// these figures (it depends on many factors).
+ /// these figures (it depends on many factors).
///
/// In general, once the optimize completes, the total size of the
/// index will be less than the size of the starting index.
/// It could be quite a bit smaller (if there were many
- /// pending deletes) or just slightly smaller.
+ /// pending deletes) or just slightly smaller.
///
/// If an Exception is hit during optimize(), for example
/// due to disk full, the index will not be corrupt and no
@@ -3176,17 +3176,17 @@
/// the index will be in non-compound format even when
/// using compound file format. This will occur when the
/// Exception is hit during conversion of the segment into
- /// compound format.
+ /// compound format.
///
/// This call will optimize those segments present in
/// the index when the call started. If other threads are
/// still adding documents and flushing segments, those
/// newly created segments will not be optimized unless you
- /// call optimize again.
+ /// call optimize again.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// CorruptIndexException if the index is corrupt
@@ -3204,7 +3204,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// maximum number of segments left
@@ -3223,7 +3223,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
public virtual void Optimize(bool doWait)
{
@@ -3238,7 +3238,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
public virtual void Optimize(int maxNumSegments, bool doWait)
{
@@ -3368,7 +3368,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
public virtual void ExpungeDeletes(bool doWait)
{
@@ -3455,7 +3455,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
public virtual void ExpungeDeletes()
{
@@ -3473,7 +3473,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
public void MaybeMerge()
{
@@ -3905,9 +3905,9 @@
/// This method will drop all buffered documents and will
/// remove all segments from the index. This change will not be
/// visible until a {@link #Commit()} has been called. This method
- /// can be rolled back using {@link #Rollback()}.
+ /// can be rolled back using {@link #Rollback()}.
///
- /// NOTE: this method is much faster than using deleteDocuments( new MatchAllDocsQuery() ).
+ /// NOTE: this method is much faster than using deleteDocuments( new MatchAllDocsQuery() ).
///
/// NOTE: this method will forcefully abort all merges
/// in progress. If other threads are running {@link
@@ -4028,7 +4028,7 @@
/// Wait for any currently outstanding merges to finish.
///
/// It is guaranteed that any merges started prior to calling this method
- /// will have completed once this method completes.
+ /// will have completed once this method completes.
///
public virtual void WaitForMerges()
{
@@ -4097,7 +4097,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// Use {@link #addIndexesNoOptimize} instead,
@@ -4229,7 +4229,7 @@
/// handled: it does not commit a new segments_N file until
/// all indexes are added. This means if an Exception
/// occurs (for example disk full), then either no indexes
- /// will have been added or they all will have been.
+ /// will have been added or they all will have been.
///
/// Note that this requires temporary free space in the
/// Directory up to 2X the sum of all input indexes
@@ -4237,20 +4237,20 @@
/// are open against the starting index, then temporary
/// free space required will be higher by the size of the
/// starting index (see {@link #Optimize()} for details).
- ///
+ ///
///
/// Once this completes, the final size of the index
/// will be less than the sum of all input index sizes
/// (including the starting index). It could be quite a
/// bit smaller (if there were many pending deletes) or
- /// just slightly smaller.
+ /// just slightly smaller.
///
///
/// This requires this index not be among those to be added.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// CorruptIndexException if the index is corrupt
@@ -4434,8 +4434,8 @@
}
/// Merges the provided indexes into this index.
- /// After this completes, the index is optimized.
- /// The provided IndexReaders are not closed.
+ /// After this completes, the index is optimized.
+ /// The provided IndexReaders are not closed.
///
/// NOTE: while this is running, any attempts to
/// add or delete documents (with another thread) will be
@@ -4444,11 +4444,11 @@
/// See {@link #AddIndexesNoOptimize(Directory[])} for
/// details on transactional semantics, temporary free
/// space required in the Directory, and non-CFS segments
- /// on an Exception.
+ /// on an Exception.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// CorruptIndexException if the index is corrupt
@@ -4644,7 +4644,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// please call {@link #Commit()}) instead
@@ -4667,7 +4667,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
///
@@ -4688,7 +4688,7 @@
/// After calling this you must call either {@link
/// #Commit()} to finish the commit, or {@link
/// #Rollback()} to revert the commit and undo all changes
- /// done since the writer was opened.
+ /// done since the writer was opened.
///
/// You can also just call {@link #Commit(Map)} directly
/// without prepareCommit first in which case that method
@@ -4696,7 +4696,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
/// Opaque Map (String->String)
@@ -4753,7 +4753,7 @@
/// crash or power loss. Note that this does not wait for
/// any running background merges to finish. This may be a
/// costly operation, so you should test the cost in your
- /// application and do it only when really necessary.
+ /// application and do it only when really necessary.
///
/// Note that this operation calls Directory.sync on
/// the index files. That call should not return until the
@@ -4765,11 +4765,11 @@
/// performance. If you have such a device, and it does
/// not have a battery backup (for example) then on power
/// loss it may still lose data. Lucene cannot guarantee
- /// consistency on such devices.
+ /// consistency on such devices.
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
///
///
@@ -4788,7 +4788,7 @@
///
/// NOTE: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See above for details.
+ /// href="#OOME">above for details.
///
public void Commit(System.Collections.Generic.IDictionary commitUserData)
{
@@ -6618,7 +6618,7 @@
/// new near real-time reader after a merge completes.
///
/// NOTE: This API is experimental and might
- /// change in incompatible ways in the next release.
+ /// change in incompatible ways in the next release.
///
/// NOTE: warm is called before any deletes have
/// been carried over to the merged segment.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/LogByteSizeMergePolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/LogByteSizeMergePolicy.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/LogByteSizeMergePolicy.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/LogByteSizeMergePolicy.cs Mon Dec 14 19:05:31 2009
@@ -53,11 +53,11 @@
/// than 50 MB) are best for interactive indexing, as this
/// limits the length of pauses while indexing to a few
/// seconds. Larger values are best for batched indexing
- /// and speedier searches.
+ /// and speedier searches.
///
/// Note that {@link #setMaxMergeDocs} is also
/// used to check whether a segment is too large for
- /// merging (it's either or).
+ /// merging (it's either or).
///
public virtual void SetMaxMergeMB(double mb)
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/LogMergePolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/LogMergePolicy.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/LogMergePolicy.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/LogMergePolicy.cs Mon Dec 14 19:05:31 2009
@@ -27,7 +27,7 @@
/// (beyond the merge factor upper bound) are encountered,
/// all segments within the level are merged. You can get or
/// set the merge factor using {@link #GetMergeFactor()} and
- /// {@link #SetMergeFactor(int)} respectively.
+ /// {@link #SetMergeFactor(int)} respectively.
///
/// This class is abstract and requires a subclass to
/// define the {@link #size} method which specifies how a
@@ -35,7 +35,7 @@
/// is one subclass that measures size by document count in
/// the segment. {@link LogByteSizeMergePolicy} is another
/// subclass that measures size as the total byte size of the
- /// file(s) for the segment.
+ /// file(s) for the segment.
///
public abstract class LogMergePolicy:MergePolicy
@@ -87,7 +87,7 @@
/// Returns the number of segments that are merged at
/// once and also controls the total number of segments
- /// allowed to accumulate in the index.
+ /// allowed to accumulate in the index.
///
public virtual int GetMergeFactor()
{
@@ -520,14 +520,14 @@
/// interactive indexing, as this limits the length of
/// pauses while indexing to a few seconds. Larger values
/// are best for batched indexing and speedier
- /// searches.
+ /// searches.
///
- /// The default value is {@link Integer#MAX_VALUE}.
+ /// The default value is {@link Integer#MAX_VALUE}.
///
/// The default merge policy ({@link
/// LogByteSizeMergePolicy}) also allows you to set this
/// limit by net size (in MB) of the segment, using {@link
- /// LogByteSizeMergePolicy#setMaxMergeMB}.
+ /// LogByteSizeMergePolicy#setMaxMergeMB}.
///
public virtual void SetMaxMergeDocs(int maxMergeDocs)
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MergePolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/MergePolicy.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MergePolicy.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MergePolicy.cs Mon Dec 14 19:05:31 2009
@@ -24,7 +24,7 @@
/// Expert: a MergePolicy determines the sequence of
/// primitive merge operations to be used for overall merge
- /// and optimize operations.
+ /// and optimize operations.
///
/// Whenever the segments in an index have been altered by
/// {@link IndexWriter}, either the addition of a newly
@@ -37,19 +37,19 @@
/// merges that should be done, or null if no merges are
/// necessary. When IndexWriter.optimize is called, it calls
/// {@link #findMergesForOptimize} and the MergePolicy should
- /// then return the necessary merges.
+ /// then return the necessary merges.
///
/// Note that the policy can return more than one merge at
/// a time. In this case, if the writer is using {@link
/// SerialMergeScheduler}, the merges will be run
/// sequentially but if it is using {@link
- /// ConcurrentMergeScheduler} they will be run concurrently.
+ /// ConcurrentMergeScheduler} they will be run concurrently.
///
/// The default MergePolicy is {@link
- /// LogByteSizeMergePolicy}.
+ /// LogByteSizeMergePolicy}.
///
/// NOTE: This API is new and still experimental
- /// (subject to change suddenly in the next release)
+ /// (subject to change suddenly in the next release)
///
/// NOTE: This class typically requires access to
/// package-private APIs (e.g. SegmentInfos) to do its job;
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MergeScheduler.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/MergeScheduler.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MergeScheduler.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MergeScheduler.cs Mon Dec 14 19:05:31 2009
@@ -23,10 +23,10 @@
/// Expert: {@link IndexWriter} uses an instance
/// implementing this interface to execute the merges
/// selected by a {@link MergePolicy}. The default
- /// MergeScheduler is {@link ConcurrentMergeScheduler}.
+ /// MergeScheduler is {@link ConcurrentMergeScheduler}.
///
/// NOTE: This API is new and still experimental
- /// (subject to change suddenly in the next release)
+ /// (subject to change suddenly in the next release)
///
/// NOTE: This class typically requires access to
/// package-private APIs (eg, SegmentInfos) to do its job;
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MultiReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/MultiReader.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MultiReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/MultiReader.cs Mon Dec 14 19:05:31 2009
@@ -44,8 +44,8 @@
/// Construct a MultiReader aggregating the named set of (sub)readers.
/// Directory locking for delete, undeleteAll, and setNorm operations is
- /// left to the subreaders.
- /// Note that all subreaders are closed if this Multireader is closed.
+ /// left to the subreaders.
+ /// Note that all subreaders are closed if this Multireader is closed.
///
/// set of (sub)readers
///
@@ -57,7 +57,7 @@
/// Construct a MultiReader aggregating the named set of (sub)readers.
/// Directory locking for delete, undeleteAll, and setNorm operations is
- /// left to the subreaders.
+ /// left to the subreaders.
///
/// indicates whether the subreaders should be closed
/// when this MultiReader is closed
@@ -98,7 +98,7 @@
}
/// Tries to reopen the subreaders.
- ///
+ ///
/// If one or more subreaders could be re-opened (i. e. subReader.reopen()
/// returned a new instance != subReader), then a new MultiReader instance
/// is returned, otherwise this instance is returned.
@@ -125,7 +125,7 @@
/// Clones the subreaders.
/// (see {@link IndexReader#clone()}).
- ///
+ ///
///
/// If subreaders are shared, then the reference count of those
/// readers is increased to ensure that the subreaders remain open
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/ParallelReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/ParallelReader.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/ParallelReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/ParallelReader.cs Mon Dec 14 19:05:31 2009
@@ -57,7 +57,7 @@
private bool hasDeletions;
/// Construct a ParallelReader.
- /// Note that all subreaders are closed if this ParallelReader is closed.
+ /// Note that all subreaders are closed if this ParallelReader is closed.
///
public ParallelReader():this(true)
{
@@ -144,7 +144,7 @@
}
/// Tries to reopen the subreaders.
- ///
+ ///
/// If one or more subreaders could be re-opened (i. e. subReader.reopen()
/// returned a new instance != subReader), then a new ParallelReader instance
/// is returned, otherwise this instance is returned.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/Payload.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/Payload.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/Payload.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/Payload.cs Mon Dec 14 19:05:31 2009
@@ -31,7 +31,7 @@
/// produces payload data.
///
/// Use {@link TermPositions#GetPayloadLength()} and {@link TermPositions#GetPayload(byte[], int)}
- /// to retrieve the payloads from the index.
+ /// to retrieve the payloads from the index.
///
///
[Serializable]
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfo.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SegmentInfo.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfo.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfo.cs Mon Dec 14 19:05:31 2009
@@ -29,7 +29,7 @@
/// to the segment.
///
/// * NOTE: This API is new and still experimental
- /// (subject to change suddenly in the next release)
+ /// (subject to change suddenly in the next release)
///
public sealed class SegmentInfo : System.ICloneable
{