Returns whether the given row is empty

@param array $dataRow Array containing data to be written. Cannot be empty.
Example $dataRow = ['data1', 1234, null, '', 'data5'];
@return bool Whether the given row is empty
778867
protected function isEmptyRow($dataRow)
    {
        $numCells = count($dataRow);
        // using "reset()" instead of "$dataRow[0]" because $dataRow can be an associative array
        return ($numCells === 1 && CellHelper::isEmpty(reset($dataRow)));
    }
1004632
protected function isEmpty($data, $exceptions)
    {
        if ($data == '') {
            $this->throwException($data, ' $data is Empty', $exceptions);
            return true;
        }
        return false;
    }
1258182
public function map(array &$row)
    {
        $inputs = $this->parse($this->inputsParams, $row);
        $outputs = $this->parse($this->outputParams, $row);


        return $inputs && $outputs ? [$inputs, $outputs] : null;
    }
1050016
public function countRows() {
        try {
            $query = $this->db->prepare($this->q->get());
            $this->bindValues($query);
            $query->execute();
            $this->clear();

            return $query->rowCount();
        } catch(\PDOException $e) {
            $this->setError('d', $e->getMessage());
            return false;
        }
    }
318068
protected function getCheckedState($row, $data)
	{
		return ($this->value === null)
			? CHtml::value($data, $this->name)
			: $this->evaluateExpression($this->value, array('data' => $data, 'row' => $row));
	}
1307013
private function isValid($row)
    {
        $result = false;

        // Check if facet_display_mode is defaulted.
        if ((int) $row['facet_display_mode'] !== FilterDisplayMode::AUTO_DISPLAYED) {
            $result = true;
        }

        // Check remaining fields are not null.
        unset($row[$this->getIdFieldName()]);
        unset($row['attribute_id']);
        unset($row['facet_display_mode']);

        if (!empty(array_filter($row, 'strlen'))) { // Preserve 0 values.
            $result = true;
        }

        return $result;
    }
7527
public function write(array $row)
    {

        // Open the file if it's not already open.
        if ($this->csv === null) {
            $csv = fopen($this->getConfig('file'), 'w');
            if (is_resource($csv) === false) {
                throw new \RuntimeException('Unable to open output file.');
            }
            $this->csv = $csv;
        }

        // If we're not using a header row, just output the values.
        // The caller will have to ensure the proper column order.
        if ($this->getConfig('header') === false) {
            return $this->put(array_values($row));
        }

        // Output the header row if we haven't already.
        if ($this->columns === null) {
            $this->columns = $this->getConfig('columns') === null ? array_keys($row) : $this->getConfig('columns');
            $this->put($this->columns);
        }

        // If this data row doesn't contain values for all the fields in the
        // header row, then insert empty values for the missing fields, so
        // that the CSV columns line up properly. Also, make sure that the
        // columns are in the order that was specified in the header row.
        $ordered = [];
        foreach ($this->columns as $column) {
            $ordered[] = array_key_exists($column, $row) === true ? $row[$column] : '';
        }
        return $this->put($ordered);

    }
627146
public function isRowsToRepeatAtTopSet() {
		if (is_array($this->_rowsToRepeatAtTop)) {
			if ($this->_rowsToRepeatAtTop[0] != 0 && $this->_rowsToRepeatAtTop[1] != 0) {
				return true;
			}
		}

		return false;
	}
308431
def is_row_empty(self, row):
    """"""
    for cell in row:
      if not self.is_cell_empty(cell):
        return False
    return True
228301
public static function isNumeric($array = null) {
		if (empty($array)) {
			return null;
		}
		if ($array === range(0, count($array) - 1)) {
			return true;
		}
		$numeric = true;
		$keys = array_keys($array);
		$count = count($keys);

		for ($i = 0; $i < $count; $i++) {
			if (!is_numeric($array[$keys[$i]])) {
				$numeric = false;
				break;
			}
		}
		return $numeric;
	}
1151769
public static function isEmpty($variable): bool
    {
        $result = true;
        if (!empty($variable) && is_array($variable)) {
            foreach ($variable as $value) {
                $result = $result && self::isEmpty($value);
            }
        } else {
            $result = empty($variable);
        }

        return $result;
    }
218161
protected function getArray($row)
    {
        if (!$row instanceof Traversable && !is_array($row)) {
            throw new InvalidArgumentException("The input is not an array or traversable");
        }
        return ($row instanceof Traversable) ? iterator_to_array($row, true) : $row;
    }
84699
public function getTrueRow($row)
    {
        if ($row) {
            array_walk(
                $row,
                function (&$item, $key) {
                    if ('' === $item) {
                        $item = null;
                    }

                    if ($item === '""') {
                        $item = '';
                    }

                    $isZeroFirstString = strlen($item) > 1 && substr($item, 0, 1) == "0";

                    if (is_numeric($item) && !$isZeroFirstString) {
                        if (intval($item) == $item) {
                            $item = intval($item);
                        } else {
                            $item = floatval($item);
                        }
                    }
                }
            );

            return array_combine($this->columns, $row);
        }

        return null;
    }
384524
public function getAlt($row)
    {
        $altField = $this->getData('config/altField') ?: self::ALT_FIELD;
        return isset($row[$altField]) ? $row[$altField] : null;
    }
607533
private function describeCount($rows = null)
    {
        if ($rows === null) {
            $rows = $this->fetchTargetRows();
        }

        if (!is_array($rows) && !($rows instanceof Traversable)) {
            throw new InvalidArgumentException(
                sprintf(
                    'The rows must be iterable; received %s',
                    is_object($rows) ? get_class($rows) : gettype($rows)
                )
            );
        }

        $cli   = $this->climate();
        $model = $this->targetModel();

        if (is_array($rows) || $rows instanceof Countable) {
            $count = count($rows);
        } elseif ($rows instanceof PDOStatement) {
            $count = $rows->rowCount();
        } else {
            $count = iterator_count($rows);
        }

        if ($count === 0) {
            $cli->comment('The object table is empty.');
            $cli->comment(
                sprintf('Only changing `%s` column.', $model->key())
            );

            return false;
        } elseif ($count === 1) {
            if (!$this->quiet()) {
                $cli->comment('The object table has 1 row.');
            }
        } else {
            if (!$this->quiet()) {
                $cli->comment(
                    sprintf('The object table has %s rows.', $count)
                );
            }
        }

        return true;
    }
759877
public function castRow($row)
    {
        $outRow = [];
        $validationErrors = [];
        foreach ($this->fields() as $fieldName => $field) {
            $value = array_key_exists($fieldName, $row) ? $row[$fieldName] : null;
            if (in_array($value, $this->missingValues())) {
                $value = null;
            }
            try {
                $outRow[$fieldName] = $field->castValue($value);
            } catch (Exceptions\FieldValidationException $e) {
                $validationErrors = array_merge($validationErrors, $e->validationErrors);
            }
        }
        if (count($validationErrors) > 0) {
            throw new Exceptions\FieldValidationException($validationErrors);
        }

        return $outRow;
    }
211503
private function validateRows($rows)
    {
        if ($rows === false)
            return $rows;
        if (empty($rows))
            return $rows ?: [];
        foreach($rows as $e=>$r){

            $rows[$e] = $this->validateRow($r);
        }
        return $rows;

    }