public virtual ICollection <SearchGroup <T> > Merge(IList <IEnumerable <ISearchGroup <T> > > shards, int offset, int topN)
{
int maxQueueSize = offset + topN;
//System.out.println("merge");
// Init queue:
for (int shardIDX = 0; shardIDX < shards.Count; shardIDX++)
{
IEnumerable <ISearchGroup <T> > shard = shards[shardIDX];
if (shard.Any())
{
//System.out.println(" insert shard=" + shardIDX);
UpdateNextGroup(maxQueueSize, new ShardIter <T>(shard, shardIDX));
}
}
// Pull merged topN groups:
List <SearchGroup <T> > newTopGroups = new List <SearchGroup <T> >();
int count = 0;
while (queue.Count != 0)
{
MergedGroup <T> group = queue.First();
queue.Remove(group);
group.IsProcessed = true;
//System.out.println(" pop: shards=" + group.shards + " group=" + (group.groupValue == null ? "null" : (((BytesRef) group.groupValue).utf8ToString())) + " sortValues=" + Arrays.toString(group.topValues));
if (count++ >= offset)
{
SearchGroup <T> newGroup = new SearchGroup <T>();
newGroup.GroupValue = group.GroupValue;
newGroup.SortValues = group.TopValues;
newTopGroups.Add(newGroup);
if (newTopGroups.Count == topN)
{
break;
}
//} else {
// System.out.println(" skip < offset");
}
// Advance all iters in this group:
foreach (ShardIter <T> shardIter in group.Shards)
{
UpdateNextGroup(maxQueueSize, shardIter);
}
}
if (newTopGroups.Count == 0)
{
return(null);
}
else
{
return(newTopGroups);
}
}
public void TestAdd()
{
const int Value = 600;
TreeSet <int> set = new TreeSet <int>();
Assert.Empty(set);
set.Add(Value);
Assert.Single(set);
Assert.Equal(Value, set.First());
int[] expected = { Value };
int[] actual = set.ToArray();
Assert.Equal(expected, actual);
}
private PlotLane NextFreeLane()
{
PlotLane p = CreateLane();
if (freePositions.IsEmpty())
{
p.position = positionsAllocated++;
}
else
{
int min = freePositions.First();
p.position = min;
freePositions.Remove(min);
}
return(p);
}
/// <summary>Returns the maximum consecutively-removed sequence number.</summary>
/// <remarks>
/// Returns the maximum consecutively-removed sequence number.
/// This is one less than the minimum remaining sequence number.
/// </remarks>
public long GetCheckpointedSequence()
{
lock (locker)
{
long sequence = lastSequence;
if (!sequences.IsEmpty())
{
sequence = sequences.First() - 1;
}
if (sequence > firstValueSequence)
{
// Garbage-collect inaccessible values:
int numToRemove = (int)(sequence - firstValueSequence);
for (int i = 0; i < numToRemove; i++)
{
values.Remove(0);
}
firstValueSequence += numToRemove;
}
return(sequence);
}
}
/// <summary>Returns the maximum consecutively-removed sequence number.</summary>
/// <remarks>
/// Returns the maximum consecutively-removed sequence number.
/// This is one less than the minimum remaining sequence number.
/// </remarks>
public long GetCheckpointedSequence()
{
var tookLock = false;
if (!_lock.IsUpgradeableReadLockHeld)
{
_lock.EnterUpgradeableReadLock();
tookLock = true;
}
long sequence = lastSequence;
if (!sequences.IsEmpty())
{
sequence = sequences.First() - 1;
}
if (sequence > firstValueSequence)
{
_lock.EnterWriteLock();
// Garbage-collect inaccessible values:
int numToRemove = (int)(sequence - firstValueSequence);
for (int i = 0; i < numToRemove; i++)
{
values.RemoveAt(0);
}
firstValueSequence += numToRemove;
_lock.ExitWriteLock();
}
if (tookLock)
{
_lock.ExitUpgradeableReadLock();
}
return(sequence);
}
/**
* @see <a href="http://en.wikipedia.org/wiki/Sweep_line_algorithm">Sweep line algorithm</a>
*/
private void SweepCleanColumns(CT_Cols cols, CT_Col[] flattenedColsArray, CT_Col overrideColumn)
{
List <CT_Col> flattenedCols = new List <CT_Col>(flattenedColsArray);
TreeSet <CT_Col> currentElements = new TreeSet <CT_Col>(CTColComparator.BY_MAX);
IEnumerator <CT_Col> flIter = flattenedCols.GetEnumerator();
CT_Col haveOverrideColumn = null;
long lastMaxIndex = 0;
long currentMax = 0;
IList <CT_Col> toRemove = new List <CT_Col>();
int pos = -1;
//while (flIter.hasNext())
while ((pos + 1) < flattenedCols.Count)
{
//CTCol col = flIter.next();
pos++;
CT_Col col = flattenedCols[pos];
long currentIndex = col.min;
long colMax = col.max;
long nextIndex = (colMax > currentMax) ? colMax : currentMax;
//if (flIter.hasNext()) {
if ((pos + 1) < flattenedCols.Count)
{
//nextIndex = flIter.next().getMin();
nextIndex = flattenedCols[pos + 1].min;
//flIter.previous();
}
IEnumerator <CT_Col> iter = currentElements.GetEnumerator();
toRemove.Clear();
while (iter.MoveNext())
{
CT_Col elem = iter.Current;
if (currentIndex <= elem.max)
{
break; // all passed elements have been purged
}
toRemove.Add(elem);
}
foreach (CT_Col rc in toRemove)
{
currentElements.Remove(rc);
}
if (!(currentElements.Count == 0) && lastMaxIndex < currentIndex)
{
// we need to process previous elements first
CT_Col[] copyCols = new CT_Col[currentElements.Count];
currentElements.CopyTo(copyCols);
insertCol(cols, lastMaxIndex, currentIndex - 1, copyCols, true, haveOverrideColumn);
}
currentElements.Add(col);
if (colMax > currentMax)
{
currentMax = colMax;
}
if (col.Equals(overrideColumn))
{
haveOverrideColumn = overrideColumn;
}
while (currentIndex <= nextIndex && !(currentElements.Count == 0))
{
NPOI.Util.Collections.HashSet <CT_Col> currentIndexElements = new NPOI.Util.Collections.HashSet <CT_Col>();
long currentElemIndex;
{
// narrow scope of currentElem
CT_Col currentElem = currentElements.First();
currentElemIndex = currentElem.max;
currentIndexElements.Add(currentElem);
while (true)
{
CT_Col higherElem = currentElements.Higher(currentElem);
if (higherElem == null || higherElem.max != currentElemIndex)
{
break;
}
currentElem = higherElem;
currentIndexElements.Add(currentElem);
if (colMax > currentMax)
{
currentMax = colMax;
}
if (col.Equals(overrideColumn))
{
haveOverrideColumn = overrideColumn;
}
}
}
//if (currentElemIndex < nextIndex || !flIter.hasNext()) {
if (currentElemIndex < nextIndex || !((pos + 1) < flattenedCols.Count))
{
CT_Col[] copyCols = new CT_Col[currentElements.Count];
currentElements.CopyTo(copyCols);
insertCol(cols, currentIndex, currentElemIndex, copyCols, true, haveOverrideColumn);
//if (flIter.hasNext()) {
if ((pos + 1) < flattenedCols.Count)
{
if (nextIndex > currentElemIndex)
{
//currentElements.removeAll(currentIndexElements);
foreach (CT_Col rc in currentIndexElements)
{
currentElements.Remove(rc);
}
if (currentIndexElements.Contains(overrideColumn))
{
haveOverrideColumn = null;
}
}
}
else
{
//currentElements.removeAll(currentIndexElements);
foreach (CT_Col rc in currentIndexElements)
{
currentElements.Remove(rc);
}
if (currentIndexElements.Contains(overrideColumn))
{
haveOverrideColumn = null;
}
}
lastMaxIndex = currentIndex = currentElemIndex + 1;
}
else
{
lastMaxIndex = currentIndex;
currentIndex = nextIndex + 1;
}
}
}
SortColumns(cols);
}
