Adds the Row that's currently being constructed to the list of finished Rows

@return $this
763077
public function addRow()
	{
		switch ( $this->currentRow->getType() )
		{
			case EnumRowType::Body:
				$this->rows[] = $this->currentRow;
				break;
			case EnumRowType::Header:
				$this->headerRows[] = $this->currentRow;
				break;
			case EnumRowType::Footer:
				$this->footerRows[] = $this->currentRow;
				break;
			default:
				throw new \InvalidArgumentException('Unknown row type');
		}

		$this->currentRow = null;

		return $this;
	}
1104281
public function addRow($rows)
    {
        $this->downloader->addRow($rows);
        $this->outputter->addRow($rows);
        $this->writer->addRow($rows);

        return $this;
    }
674440
public function columns()
    {
        $args = func_get_args();
        while ($arg = array_shift($args)) {
            $this->columns->add($arg);
        }
        return $this;
    }
1160794
protected function sqlFinish()
	{
		$this->query_sql = ob_get_clean();

		// Flatten parameters before bind
		if (!empty($this->query_params)) {
			$this->query_params = call_user_func_array('array_merge', $this->query_params);
		}
		return $this;
	}
222336
public function concat($list): self
    {
        $this->internalDataListUpdate();
        foreach ($list as $object) {
            array_push($this->internalDataListData, $object);
        }
        return $this;
    }
1234421
def AddRow(self, *args):
        '''  '''
        NumRows = len(self.Rows)  # number of existing rows is our row number
        CurrentRowNumber = NumRows  # this row's number
        CurrentRow = []  # start with a blank row and build up
        # -------------------------  Add the elements to a row  ------------------------- #
        for i, element in enumerate(args):  # Loop through list of elements and add them to the row
            element.Position = (CurrentRowNumber, i)
            element.ParentContainer = self
            CurrentRow.append(element)
        # -------------------------  Append the row to list of Rows  ------------------------- #
        self.Rows.append(CurrentRow)
1019909
public function add($row = []): CollectionInterface
    {
        //if it's an array
        if (is_array($row)) {
            //make it a model
            $row = $this->getModel($row);
        }

        //add it now
        $this->data[] = $row;

        return $this;
    }
818924
public function setRows(array $rows)
    {
        $this->rows = $rows;
        $this->setKeys(array_keys($this->rows[0]));
        return $this;
    }
844215
public function refreshRowDimensions()
    {
        $currentRowDimensions = $this->getRowDimensions();
        $newRowDimensions = array();

        foreach ($currentRowDimensions as $objRowDimension) {
            $newRowDimensions[$objRowDimension->getRowIndex()] = $objRowDimension;
        }

        $this->_rowDimensions = $newRowDimensions;

        return $this;
    }
313087
def add_row(self, array):
        

        self._check_row_size(array)

        if not hasattr(self, "_dtype"):
            self._dtype = ["a"] * self._row_size

        cells = []
        for i, x in enumerate(array):
            cells.append(self._str(i, x))
        self._rows.append(cells)
        return self
1157931
public function next()
    {

        $this->index++;

        if ($this->className) {
            $this->value = $this->query->getObject($this->className);
        } else {
            $this->value = $this->query->getRow();
        }

        return $this;
    }
741932
def addRow(self, *row):
        
        row     = [ str(item) for item in row ]
        len_row = [ len(item) for item in row ]
        width   = self.__width
        len_old = len(width)
        len_new = len(row)
        known   = min(len_old, len_new)
        missing = len_new - len_old
        if missing > 0:
            width.extend( len_row[ -missing : ] )
        elif missing < 0:
            len_row.extend( [0] * (-missing) )
        self.__width = [ max( width[i], len_row[i] ) for i in compat.xrange(len(len_row)) ]
        self.__cols.append(row)
42325
public function last()
    {
        $this->seek($this->count() - 1);

        if ($this->count()) {
            return $this->rows[ $this->position ];
        }

        return new Row();
    }
1243457
public function addRow($data = null)
    {
        $this->rowIndex++;
        if (is_array($data)) {
            foreach ($data as $column => $content) {
                $this->rows[ $this->rowIndex ][ $column ] = $content;
            }
        }

        return $this;
    }
599480
def on_add_rows(self, event):
        
        num_rows = self.rows_spin_ctrl.GetValue()
        #last_row = self.grid.GetNumberRows()
        for row in range(num_rows):
            self.grid.add_row()
            #if not self.grid.changes:
            #    self.grid.changes = set([])
            #self.grid.changes.add(last_row)
            #last_row += 1
        self.main_sizer.Fit(self)
20375
public function add( $data )
	{
		$columnNum = 0;
		$rowNum = $this->_iterator->current()->getRowIndex();

		foreach( (array) $data as $value ) {
			$this->_sheet->setCellValueByColumnAndRow( $columnNum++, $rowNum, $value );
		}

		$this->_iterator->next();
	}
1096679
protected function processCurrentTable()
	{
		$firstRow = $this->table['rows'][0];
		$lastRow  = end($this->table['rows']);
		$this->createTableTags($firstRow['pos'], $lastRow['pos'] + strlen($lastRow['line']));

		$this->addTableHead();
		$this->createSeparatorTag($this->table['rows'][1]);
		$this->addTableBody();
	}