Evaluate the result of the function.

@param array Array of function closures
@param RowInterface $row
972954
public function execute($functionMap, $row)
    {
        $this->replaceColumnOperands($functionMap, $row);

        $functionName = $this->getFunctionName();
        if (!isset($functionMap[$functionName])) {
            throw new InvalidQueryException(sprintf('Unknown function "%s", known functions are "%s"',
                $functionName,
                implode(', ', array_keys($functionMap))
            ));
        }

        $callable = $functionMap[$functionName];
        $args = $this->getArguments();
        array_unshift($args, $row);
        array_unshift($args, $this);
        $value = call_user_func_array($callable, $args);

        return $value;
    }
70063
public function process(array $row)
    {
        foreach ($row as &$item) {
            if ($item instanceof DateTimeInterface) {
                $item = $item->format($this->format);
            }
        }

        return $row;
    }
700534
public function buildRow(Model\RowInterface $row)
    {
        $view = new RowView();
        $attributes = $view->getAttributes()->addClass('cms-row');

        if ($this->editor->isEnabled()) {
            $container = $row->getContainer();

            $attributes
                ->setId('cms-row-' . $row->getId())
                ->setData([
                    'id'       => $row->getId(),
                    'position' => $row->getPosition(),
                    'actions'  => [
                        'add'       => !is_null($container),
                        //'edit'         => true,
                        'layout'    => true,
                        //'change_type'  => !$row->isNamed(),
                        'move_up'   => !$row->isFirst(),
                        'move_down' => !$row->isLast(),
                        'remove'    => !$row->isAlone(),
                    ],
                ]);
        }

        // Layout
        $this->editor->getLayoutAdapter()->buildRow($row, $view);

        foreach ($row->getBlocks() as $block) {
            $view->blocks[] = $this->buildBlock($block);
        }

        return $view;
    }
16536
public function onInput($row)
    {
        $keys = array_keys($row);
        $values = array_values($row);
        for ($i = 0; $i < count($keys); $i++) {
            if (isset($this->params[$keys[$i]])) {
                $keys[$i] = $this->params[$keys[$i]];
            }
        }
        $this->next(array_combine($keys, $values));
    }
826552
private function render($row = 0)
    {
        if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
            $rows = ($this->showSummary ? array_merge($this->rows, [$this->getSummary()]) : $this->rows);
            $this->output->reWrite($rows, !$this->showSummary);
        } else {
            $this->output->writeln($this->rows[$row]);
        }
    }
229078
private function transformRow(&$row)
    {
        // Check modify for any specific key manipulations.
        if (array_has($this->config, 'modify')) {
            foreach ($row as $key => &$value) {
                if (array_has($this->config['modify'], $key)) {
                    $this->config['modify'][$key]($value, $row);
                }
                unset($value);
            }
        }
    }
1056523
public function setRelation(Row $row): void
    {
        $modelName = $row->getTable()->getModel();
        $this->relations[$modelName] = [$row];
    }
253939
public function process(array $row)
    {
        foreach ($this->processors as $processor) {
            $row = call_user_func($processor, $row);
        }

        return $row;
    }
1252287
protected function validateRowInRange($row)
    {
        $row = static::validateRow($row);
        if ($row > $this->rows) {
            throw new Exception('Requested Row exceeds matrix size');
        }

        return $row;
    }
501576
private function renderRow(array $row, $cellFormat) {
        if (empty($row)) {
            return;
        }

        $rowContent = $this->renderColumnSeparator();
        foreach ($this->getRowColumns($row) as $column) {
            $rowContent .= $this->renderCell($row, $column, $cellFormat);
            $rowContent .= $this->renderColumnSeparator();
        }
        $this->output->writeln($rowContent);
    }
785896
public function beforeInsert(Row $row): void
    {
        foreach ($row->values() as $column => $value) {
            $this->generateFakeDataIfNeeded($row, $column, $value);
        }
    }
32056
private function passesFilter(array $row)
    {
        foreach ($row as $name => $value) {
            if (isset($this->rules[$name])) {
                // check all rules for a given attribute
                foreach ($this->rules[$name] as $rule) {
                    /* @var $rule MatcherInterface */
                    if (!$rule->match($value)) {
                        return false;
                    }
                }
            }
        }

        return true;
    }
527712
public function processRow($row)
    {
        if (!$this->colsprinted && $this->showheaders) {
            $first = true;
            foreach ($row as $fieldName => $ignore) {
                if ($first) {
                    $first = false;
                } else {
                    $line .= ",";
                }
                $line .= $fieldName;
            }

            $this->out->write($line);
            $this->out->write(PHP_EOL);

            $line = "";
            $colsprinted = true;
        } // if show headers

        $first = true;
        foreach ($row as $columnValue) {
            if ($columnValue != null) {
                $columnValue = trim($columnValue);
            }

            if ($first) {
                $first = false;
            } else {
                $line .= $this->coldelimiter;
            }
            $line .= $columnValue;
        }

        $this->out->write($line);
        $this->out->write($this->rowdelimiter);
    }
206714
public function execute($row, $name = null)
    {
        parent::execute($row, $name);
        return $row[MemberNames::ROW_ID];
    }
936201
function _calculateCellLengths($row) {
        for ($i = 0; $i < count($row); $i++) {
            if (!isset($this->_cell_lengths[$i])) {
                $this->_cell_lengths[$i] = 0;
            }
            $this->_cell_lengths[$i] = max($this->_cell_lengths[$i],
                $this->_strlen($row[$i]));
        }
    }
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;
    }
669154
public function moveDown(Model\RowInterface $row)
    {
        $sibling = $this->editor->getRepository()->findSiblingRow($row, true);
        if (null === $sibling) {
            throw new InvalidOperationException(
                "The row can't be moved down as no sibling row has been found."
            );
        }

        $row->setPosition($row->getPosition() + 1);
        $sibling->setPosition($sibling->getPosition() - 1);

        $this->sortChildrenByPosition($row->getContainer(), 'rows');

        return $sibling;
    }