Will attempt to refill headers if we see more fields.
@param eachRow
9646
protected void tryRefillHeaders(JSONObject eachRow) {
        if (eachRow == null) {
            return;
        }
        if (eachRow.keySet().size() > baseFieldNames.size() - 1) {//i.e excluding timestamp, if the sizes are not same then we have not covered all field names
            baseFieldNames.clear();
            baseFieldNames.add("timestamp");
            baseFieldNames.addAll(eachRow.keySet());
        }
    }
970223
public void addRow(boolean[] values) {
    Node<ColumnName> prev = null;
    for(int i=0; i < values.length; ++i) {
      if (values[i]) {
        ColumnHeader<ColumnName> top = columns.get(i);
        top.size += 1;
        Node<ColumnName> bottom = top.up;
        Node<ColumnName> node = new Node<ColumnName>(null, null, bottom, 
                                                     top, top);
        bottom.down = node;
        top.up = node;
        if (prev != null) {
          Node<ColumnName> front = prev.right;
          node.left = prev;
          node.right = front;
          prev.right = node;
          front.left = node;
        } else {
          node.left = node;
          node.right = node;
        }
        prev = node;
      }
    }
  }
455641
public void addRow(String[] data) {

        if (data.length != iColCount) {
            return;
        }

        String[] row = new String[iColCount];

        for (int i = 0; i < iColCount; i++) {
            row[i] = data[i];

            if (row[i] == null) {
                row[i] = "(null)";
            }
        }

        vData.addElement(row);

        iRowCount++;
    }
177785
private void addInternalHeaderFields(String name, String value) {
        String key = normalisedHeaderName(name);
        Vector<String> v = getHeaders(key);
        if (v == null) {
            v = new Vector<>();
            mHeaderFields.put(key, v);
        }

        if (value != null) {
            v.add(value);
        } else {
            mHeaderFields.remove(key);
        }
    }
984771
void resetRows(int i, int marking) {
        for (int j = (i * mCols); j < data.length; j++)
            if (data[j] == marking) data[j] = 1;
    }
362179
public void addCell(String row, String col, String value) throws Exception {
		HeaderInfo rowIndex = rowLookup.get(row);
		HeaderInfo colIndex = columnLookup.get(col);
		if (rowIndex == null) {
			throw new Exception("Row " + row + " not found in worksheet");
		}
		if (colIndex == null) {
			throw new Exception("Column " + col + " not found in worksheet");
		}


		data[rowIndex.getIndex()][colIndex.getIndex()] = new CompactCharSequence(value);
	}
1310809
public void flushSomeAvailableRowsFrom(final XMLUtil util, final Appendable appendable, final int rowIndex)
            throws IOException {
        if (rowIndex == 0)
            this.appendPreamble(util, appendable);
        this.appendRows(util, appendable, rowIndex);
    }
893354
void switchTwoRowHeaders(int rowIndex, int rowToIndex) {
        Object cellData = getRowHeaders()[rowToIndex];
        getRowHeaders()[rowToIndex] = getRowHeaders()[rowIndex];
        getRowHeaders()[rowIndex] = cellData;
    }
875363
private void addRow() {
    BloomFilter[] tmp = new BloomFilter[matrix.length + 1];

    for (int i = 0; i < matrix.length; i++) {
      tmp[i] = matrix[i];
    }

    tmp[tmp.length-1] = new BloomFilter(vectorSize, nbHash, hashType);

    matrix = tmp;
  }
331223
public void visit(WtTableRow n)
	{
		if (currentRow == null)
		{
			currentRow = new ArrayList<String>();
			iterate(n);
			if(currentRow.size() > 0)
			{
				rows.add(currentRow);
			}
			if(currentRow.size() == n.getBody().size()) {
				StringBuilder tableRowFormatted = new StringBuilder();
				for(int i = 0; i < currentRow.size(); i++) {
					tableRowFormatted.append(currentRow.get(i));
					if(i+1 < currentRow.size()) {
						// appending a separator char only in between cells here
						tableRowFormatted.append('|');
					}
				}
				writeWord(tableRowFormatted.toString());
			}
			currentRow = null;
		}
	}
935163
function tableDoesNotHaveHeaderRow(rows) {
        var headerRow = rows[0];

        var headerCells = headerRow.children;

        for (var i = 0; i < headerCells.length; i++) {
            if (headerCells[i].tagName != 'TH') {
                return true;
            }
        }
        return false;
    }
612504
public void each(MatrixProcedure procedure) {
        MatrixIterator it = iterator();

        while (it.hasNext()) {
            double x = it.next();
            int i = it.rowIndex();
            int j = it.columnIndex();
            procedure.apply(i, j, x);
        }
    }
71664
public void setRowsSpanned(final Table table, final TableAppender appender, final int rowIndex,
                               final int colIndex, final int n) throws IOException {
        if (n <= 1) return;

        final TableCell firstCell = this.getRowSecure(table, appender, rowIndex, false)
                .getOrCreateCell(colIndex);
        if (firstCell.isCovered()) return;

        firstCell.markRowsSpanned(n);
        this.coverCellsBelow(table, appender, rowIndex, colIndex, n);
    }
137125
private void executeRow(Example valuesRow, Example headers, Fixture rowFixtureAdapter)
    {
        valuesRow.annotate( Annotations.right() );

        Statistics rowStats = new Statistics();

        for (int i = 0; i != valuesRow.remainings(); ++i)
        {
            Example cell = valuesRow.at( i );

            if (i < headers.remainings())
            {
                // We can do the cast because #parseColumn returns an ExpectedColumn
                ExpectedColumn column = (ExpectedColumn) columns[i];

                try
                {
                    chekOneCell(rowFixtureAdapter, rowStats, cell, column);
                }
                catch (Exception e)
                {
                    cell.annotate( exception( e ) );
                    stats.exception();
                }
            }
            else
            {
                cell.annotate( ignored( cell.getContent() ) );
            }
        }
        applyRowStatistic(rowStats);
    }
1019087
private List<ExpandedPair> checkRows(List<ExpandedRow> collectedRows, int currentRow) throws NotFoundException {
    for (int i = currentRow; i < rows.size(); i++) {
      ExpandedRow row = rows.get(i);
      this.pairs.clear();
      for (ExpandedRow collectedRow : collectedRows) {
        this.pairs.addAll(collectedRow.getPairs());
      }
      this.pairs.addAll(row.getPairs());

      if (!isValidSequence(this.pairs)) {
        continue;
      }

      if (checkChecksum()) {
        return this.pairs;
      }

      List<ExpandedRow> rs = new ArrayList<>(collectedRows);
      rs.add(row);
      try {
        // Recursion: try to add more rows
        return checkRows(rs, i + 1);
      } catch (NotFoundException e) {
        // We failed, try the next candidate
      }
    }

    throw NotFoundException.getNotFoundInstance();
  }
946354
public void setRows(int rows)
    {
        if (rows < 0)
        {
            throw new IllegalArgumentException("rows: " + rows);
        }
        getStateHelper().put(PropertyKeys.rows, rows ); 
    }
1175581
public function allRows()
    {
        call_user_func($this->callback, new TableWidget($this->name, $this->label, $this->authSystem, $this->requiredPermissions, $this->table));
    }