public bool ActOnCells(TextAsset textAsset, CellVisitor cellVisitor, out TextAssetTableResult tableResult)
{
tableResult = new TextAssetTableResult();
var i = 0;
foreach (var row in SplitTableToRows(textAsset))
{
tableResult.Rows++;
var colCount = 0;
var j = 0;
foreach (var col in SplitRowToCells(row))
{
colCount++;
if (cellVisitor(i, j, col))
{
tableResult.CellsActedOn++;
}
j++;
}
tableResult.Cols = Math.Max(tableResult.Cols, colCount);
i++;
}
return(tableResult.CellsActedOn > 0);
}
public void Visit(CellVisitor visitor)
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
visitor(cells[x, y]);
}
}
}
override public void Accept(ModelComponentVisitor visitor)
{
if (visitor is CellVisitor)
{
CellVisitor cellVisitor = (CellVisitor)visitor;
cellVisitor.Visit(this);
}
else
{
base.Accept(visitor);
}
}
// Visits all (cell_id, label) pairs in the given index that intersect the
// given S2CellUnion "target", terminating early if the given CellVisitor
// function returns false (in which case VisitIntersectingCells returns false
// as well). Each (cell_id, label) pair in the index is visited at most
// once. (If the index contains duplicates, then each copy is visited.)
public bool VisitIntersectingCells(S2CellUnion target, CellVisitor visitor)
{
if (!target.CellIds.Any())
{
return(true);
}
var contents = new ContentsEnumerator(this);
var targetIndex = 0;
var targetLimit = target.CellIds.Count;
var rangeIndex = 0;
do
{
var limitId = range_nodes_[rangeIndex + 1].StartId;
if (limitId <= target.CellIds[targetIndex].RangeMin())
{
// Only seek when necessary.
var rangeTarget = target.CellIds[targetIndex].RangeMin();
rangeIndex = range_nodes_.GetUpperBound(new RangeNode(rangeTarget, -1)) - 1;
}
for (; range_nodes_[rangeIndex].StartId <= target.CellIds[targetIndex].RangeMax(); rangeIndex++)
{
var rNode = range_nodes_[rangeIndex];
contents.StartUnion(rNode);
while (contents.MoveNext())
{
if (!visitor(contents.Current.CellId, contents.Current.Label))
{
return(false);
}
}
}
// Check whether the next target cell is also contained by the leaf cell
// range that we just processed. If so, we can skip over all such cells
// using binary search. This speeds up benchmarks by between 2x and 10x
// when the average number of intersecting cells is small (< 1).
if (++targetIndex < targetLimit && target.CellIds[targetIndex].RangeMax() < range_nodes_[rangeIndex].StartId)
{
// Skip to the first target cell that extends past the previous range.
targetIndex = target.CellIds.GetLowerBound(range_nodes_[rangeIndex].StartId, targetIndex + 1, targetLimit);
if (target.CellIds[targetIndex - 1].RangeMax() >= range_nodes_[rangeIndex].StartId)
{
--targetIndex;
}
}
} while (targetIndex < targetLimit);
return(true);
}
public bool accept(CellVisitor visitor)
{
return visitor.visit(this);
}
public bool accept(CellVisitor visitor)
{
return(visitor.visit(this));
}
public Cell(CellVisitor visitor)
{
Visitor = visitor;
}
