/// <summary> Tries to acquire the WriteLock on this directory.
/// this method is only valid if this IndexReader is directory owner.
///
/// </summary>
/// <throws> IOException If WriteLock cannot be acquired. </throws>
private void AquireWriteLock()
{
if (stale)
{
throw new System.IO.IOException("IndexReader out of date and no longer valid for delete, undelete, or setNorm operations");
}
if (this.writeLock == null)
{
Lock writeLock = directory.MakeLock(IndexWriter.WRITE_LOCK_NAME);
if (!writeLock.Obtain(IndexWriter.WRITE_LOCK_TIMEOUT))
// obtain write lock
{
throw new System.IO.IOException("Index locked for write: " + writeLock);
}
this.writeLock = writeLock;
// we have to check whether index has changed since this reader was opened.
// if so, this reader is no longer valid for deletion
if (SegmentInfos.ReadCurrentVersion(directory) > segmentInfos.GetVersion())
{
stale = true;
this.writeLock.Release();
this.writeLock = null;
throw new System.IO.IOException("IndexReader out of date and no longer valid for delete, undelete, or setNorm operations");
}
}
}
/// <summary> Check whether this IndexReader still works on a current version of the index.
/// If this is not the case you will need to re-open the IndexReader to
/// make sure you see the latest changes made to the index.
///
/// </summary>
/// <throws> IOException </throws>
public virtual bool IsCurrent()
{
if (SegmentInfos.ReadCurrentVersion(directory) != segmentInfos.GetVersion())
{
return(false);
}
return(true);
}
/// <summary> Check whether this IndexReader still works on a current version of the index.
/// If this is not the case you will need to re-open the IndexReader to
/// make sure you see the latest changes made to the index.
///
/// </summary>
/// <throws> IOException </throws>
public virtual bool IsCurrent()
{
lock (directory)
{
// in- & inter-process sync
Lock commitLock = directory.MakeLock(IndexWriter.COMMIT_LOCK_NAME);
bool locked = false;
try
{
locked = commitLock.Obtain(IndexWriter.COMMIT_LOCK_TIMEOUT);
return(SegmentInfos.ReadCurrentVersion(directory) == segmentInfos.GetVersion());
}
finally
{
if (locked)
{
commitLock.Release();
}
}
}
}
/// <summary> Reads version number from segments files. The version number is
/// initialized with a timestamp and then increased by one for each change of
/// the index.
///
/// </summary>
/// <param name="directory">where the index resides.
/// </param>
/// <returns> version number.
/// </returns>
/// <throws> IOException if segments file cannot be read. </throws>
public static long GetCurrentVersion(Directory directory)
{
return(SegmentInfos.ReadCurrentVersion(directory));
}
/// <summary> Check whether this IndexReader still works on a current version of the index.
/// If this is not the case you will need to re-open the IndexReader to
/// make sure you see the latest changes made to the index.
///
/// </summary>
/// <throws> IOException </throws>
public virtual bool IsCurrent()
{
return(SegmentInfos.ReadCurrentVersion(directory) == segmentInfos.GetVersion());
}
/// <summary> Check whether this IndexReader is still using the
/// current (i.e., most recently committed) version of the
/// index. If a writer has committed any changes to the
/// index since this reader was opened, this will return
/// <code>false</code>, in which case you must open a new
/// IndexReader in order to see the changes. See the
/// description of the <a href="IndexWriter.html#autoCommit"><code>autoCommit</code></a>
/// flag which controls when the {@link IndexWriter}
/// actually commits changes to the index.
///
/// </summary>
/// <throws> CorruptIndexException if the index is corrupt </throws>
/// <throws> IOException if there is a low-level IO error </throws>
public override bool IsCurrent()
{
EnsureOpen();
return SegmentInfos.ReadCurrentVersion(directory) == segmentInfos.GetVersion();
}
