Whether any of the columns in the row has a message

@param mixed $row the data object to use to check the column for
messages.

@return boolean true if any of the columns in the row has a message,
otherwise false.
344731
protected function rowHasMessage($row)
    {
        $has_message = false;

        foreach ($this->columns as $column) {
            if ($column->hasMessage($row)) {
                $has_message = true;
                break;
            }
        }

        if (!$has_message) {
            foreach ($this->spanning_columns as $column) {
                if ($column->hasMessage($row)) {
                    $has_message = true;
                    break;
                }
            }
        }

        return $has_message;
    }
457853
public boolean containsRow(Map<String, String> row) {
        for (CsvRow csvRow : data) {
            if (csvRow.contains(row)) {
                return true;
            }
        }
        return false;
    }
35539
protected function cleanupRow($row)
    {
        foreach ($row as $key => $column) {
            if ($this->isQuoted($column)) {
                $column = $this->unescape($this->unquote($column));
            }
            if ($this->isSerialized($column)) {
                $column = $this->unserialize($column);
            }
            if ('N;' === $column) {
                $column = null;
            }
            $row[$key] = $column;
        }

        return $row;
    }
318402
public function reset( $row = null ) {

		$row = pods_absint( $row );

		$this->row = false;

		if ( isset( $this->data[ $row ] ) ) {
			$this->row = get_object_vars( $this->data[ $row ] );
		}

		if ( empty( $row ) ) {
			$this->row_number = - 1;
		} else {
			$this->row_number = $row - 1;
		}

		return $this->row;
	}
584834
public function hasTable($table)
	{
            $sql = $this->grammar->compileTableExists($table);
            $statement = $this->connection->getBatchQuery($sql, []);
            $data = $statement->getResultSet();
            return $data->result()? true: false;
          
	}
354762
public function hasColumn($col)
    {
        if (!$this->getModel()->getOwnColumns()) return true;
        if (in_array($col, $this->getModel()->getOwnColumns())) return true;
        if (in_array($col, $this->getModel()->getExprColumns())) return true;
        foreach ($this->_getSiblingRows() as $r) {
            if ($r->hasColumn($col)) return true;
        }
        return false;
    }
962141
public function getHighestColumn($row = null)
    {
        if ($row == null) {
            return $this->cachedHighestColumn;
        }
        return $this->getHighestDataColumn($row);
    }
1309175
public function result($row, $col)
    {
        if (!$this->result) {
            return false;
        }

        switch ($this->mode) {

            case "mysql":
            case "sqlite":
                $this->seek($row);
                $data = $this->fetch(true);
                $value = $data[$col];
                $this->seek($this->position);
                break;

            case "postgres":
            case "redshift":
                $value = pg_fetch_result($this->result, $row, $col);
                break;

            case "odbc":
                odbc_fetch_row($this->result, $row + 1);
                $value = odbc_result($this->result, $col + 1);
                break;

            case "mssql":
                $value = mssql_result($this->result, $row, $col);
                break;

            case "mssqlsrv":
                $value = sqlsrv_result($this->result, $row, $col);
                break;
        }

        $value = rtrim($value);

        return $value;
    }
24257
public function hasMessage()
    {
        $has_message = false;

        foreach ($this->renderers as $renderer) {
            if ($renderer->hasMessage()) {
                $has_message = true;
                break;
            }
        }

        return $has_message;
    }
476983
protected function hasValidTable()
	{
		return (isset($this->table) && count($this->table['rows']) > 2 && $this->isValidSeparator($this->table['rows'][1]['line']));
	}
380461
public function isVisible($row) {
        if (false === $this->visible) // check if it's visible
            return false;
        elseif (is_string($this->visible)) {
            $visible = true;
            eval("\$visible = {$this->visible};");
            if (false == $visible)
                return false;
        }
        return true;
    }
919744
private function checkRowConsistency($row)
    {
        if ( $this->strict === false ) {
            return;
        }

        $current = count($row);

        if ( $this->rowConsistency === null ) {
            $this->rowConsistency = $current;
        }

        if ( $current !== $this->rowConsistency ) {
            throw new StrictViolationException();
        }

        $this->rowConsistency = $current;
    }
976109
private function validateRow($row)
    {
        if ($row === false)
            return $row;
        $resolver = new OptionsResolver();
        $resolver->setRequired([
            'class',
            'columns',
        ]);
        $resolver->setAllowedTypes('class', 'string');
        $resolver->setAllowedTypes('columns', 'array');
        $row = $resolver->resolve($row);
        if (empty($row['columns']))
            trigger_error(sprintf('An array of columns is compulsory for each row.'), E_USER_ERROR);
        $row['columns'] = $this->validateColumns($row['columns']);
        return $row;
    }
1025515
protected function assertIndexesAreValid($row, $column, $height = 1, $width = 1)
    {
        Assert::assertIntegerBetween(0, $this->rows - $height, $row, 'row');
        Assert::assertIntegerBetween(0, $this->columns - $width, $column, 'column');
    }
1155624
public static function isRowActions($row)
    {
        return (count($row) == count(static::makeEmptyActionRow())) && isset($row[Metrics::INDEX_NB_ACTIONS]);
    }
89434
public function result($row = 0)
    {
        return isset($this->results[$row]) ? $this->results[$row] : false;
    }
164005
protected function isDeletedRow($row, $attribute)
    {
        $rowAttribute = $row;
        unset($rowAttribute[$this->relationalData[$attribute]['junctionColumn']]);

        foreach ($this->relationalData[$attribute]['newRows'] as $newRow) {
            $newRowAttributes = $newRow;
            unset($newRowAttributes[$this->relationalData[$attribute]['junctionColumn']]);
            if ($newRowAttributes == $rowAttribute) {
                return false;
            }
        }

        return true;
    }