public IEnumerable<LTrieRow> IterateBackwardStartFrom(byte[] key, bool includeStartKey, ITrieRootNode readRootNode)
{
this.CheckTableIsOperable();
if (readRootNode==null)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardStartFrom(key, includeStartKey,false);
}
else
{
Backward bw = new Backward((LTrieRootNode)readRootNode);
return bw.IterateBackwardStartFrom(key, includeStartKey,true);
}
}
public IEnumerable<LTrieRow> IterateBackwardSkipFrom(byte[] key, ulong skippingQuantity, bool useCache)
{
this.CheckTableIsOperable();
if (!useCache)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardSkipFrom(key, skippingQuantity, false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardSkipFrom(key, skippingQuantity, true);
}
}
public IEnumerable<LTrieRow> IterateBackwardStartFrom(byte[] key, bool includeStartKey)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardStartFrom(key, includeStartKey,true);
}
public IEnumerable<LTrieRow> IterateBackwardSkip(ulong skippingQuantity, ITrieRootNode readRootNode)
{
this.CheckTableIsOperable();
if (readRootNode==null)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardSkip(skippingQuantity,false);
}
else
{
Backward bw = new Backward((LTrieRootNode)readRootNode);
return bw.IterateBackwardSkip(skippingQuantity,true);
}
}
public IEnumerable<LTrieRow> IterateBackwardSkipFrom(byte[] key, ulong skippingQuantity)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardSkipFrom(key, skippingQuantity,true);
}
public IEnumerable<LTrieRow> IterateBackwardFromTo(byte[] startKey, byte[] stopKey, bool includeStartKey, bool includeStopKey, bool useCache)
{
this.CheckTableIsOperable();
if (!useCache)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardFromTo(startKey, stopKey, includeStartKey, includeStopKey, false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardFromTo(startKey, stopKey, includeStartKey, includeStopKey, true);
}
}
public LTrieRow IterateBackwardForMaximal(ITrieRootNode readRootNode)
{
this.CheckTableIsOperable();
if (readRootNode==null)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardForMaximal(false);
}
else
{
Backward bw = new Backward((LTrieRootNode)readRootNode);
return bw.IterateBackwardForMaximal(true);
}
}
public LTrieRow IterateBackwardForMaximal()
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardForMaximal(true);
}
public IEnumerable<LTrieRow> IterateBackward()
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackward(true);
}
/// <summary>
///
/// </summary>
/// <param name="startKey"></param>
/// <returns></returns>
public IEnumerable<LTrieRow> IterateBackwardStartsWithClosestToPrefix(byte[] startKey)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardStartsWithClosestToPrefix(startKey, true);
}