Calculate the number of columns organize data

@return array
556195
public function result()
    {
        $keys      = array_keys($this->data);
        $first_key = reset($keys);

        return (!is_int($first_key)) ? $this->associativeColumns() : $this->columns();
    }
1068064
public function columns(): array
    {
        return [
            new CensusColumnSurname($this, 'Nom', 'Nom de famille'),
            new CensusColumnGivenNames($this, 'Prénom', 'Prénom usuel'),
            new CensusColumnRelationToHead($this, 'Parenté', 'Parenté avec le chef de ménage ou situation dans le ménage'),
            new CensusColumnBirthYear($this, 'Année', 'Année de naissance'),
            new CensusColumnNationality($this, 'Nationalité', ''),
            new CensusColumnOccupation($this, 'Profession', ''),
        ];
    }
5647
public function get_sort_columns() {
        $result = parent::get_sort_columns();

        $assignment = $this->assignment->get_instance();
        if (empty($assignment->blindmarking)) {
            $result = array_merge($result, array('userid' => SORT_ASC));
        } else {
            $result = array_merge($result, [
                    'COALESCE(s.timecreated, '  . time()        . ')'   => SORT_ASC,
                    'COALESCE(s.id, '           . PHP_INT_MAX   . ')'   => SORT_ASC,
                    'um.id'                                             => SORT_ASC,
                ]);
        }
        return $result;
    }
1174853
protected int getNumOfCols() {
        if (!columns.isEmpty()) return getHeadRegularColCnt() + columns.size();
        if (loaded && !colTitleWidgets.isEmpty()) return getHeadRegularColCnt() + colTitleWidgets.size();
        return getHeadRegularColCnt();
    }
169932
private function calculateColumnWidth()
    {
        foreach ($this->rows as $rowIndex => $row) {
            foreach ($row as $columnIndex => $column) {
                if ( ! isset($this->columnWidths[ $columnIndex ])) {
                    $this->columnWidths[ $columnIndex ] = strlen($column);
                } else {
                    if (strlen($column) > $this->columnWidths[ $columnIndex ]) {
                        $this->columnWidths[ $columnIndex ] = strlen($column);
                    }
                }
            }
        }

        return $this->columnWidths;
    }
550470
public function getColumnWidths()
    {
        foreach ($this->columnWidths as $column => $width) {
            if ($width > $this->maxColumnWidth) {
                $this->columnWidths[$column] = $this->maxColumnWidth;
            } elseif ($width < $this->minColumnWidth) {
                $this->columnWidths[$column] = $this->minColumnWidth;
            }
        }

        return $this->columnWidths;
    }
846210
public function columns(): array
    {
        return [
            new CensusColumnFullName($this, 'Name', 'Name'),
            new CensusColumnAge($this, 'Age', 'Age'),
            new CensusColumnSexMF($this, 'Sex', 'Sex'),
            new CensusColumnMonthIfBornWithinYear($this, 'Mon', 'If born within the year, state month'),
            new CensusColumnRelationToHead($this, 'Relation', 'Relation to head of household'),
            new CensusColumnNull($this, 'S', 'Single'),
            new CensusColumnNull($this, 'M', 'Married'),
            new CensusColumnNull($this, 'W/D', 'Widowed, Divorced'),
            new CensusColumnMarriedWithinYear($this, 'MY', 'Married during census year'),
            new CensusColumnOccupation($this, 'Occupation', 'Profession, occupation, or trade'),
            new CensusColumnNull($this, 'UnEm', 'Number of months the person has been unemployed during the census year'),
            new CensusColumnNull($this, 'Sick', 'Sickness or disability'),
            new CensusColumnNull($this, 'Blind', 'Blind'),
            new CensusColumnNull($this, 'DD', 'Deaf and dumb'),
            new CensusColumnNull($this, 'Idiotic', 'Idiotic'),
            new CensusColumnNull($this, 'Insane', 'Insane'),
            new CensusColumnNull($this, 'Disabled', 'Maimed, crippled, bedridden or otherwise disabled'),
            new CensusColumnNull($this, 'School', 'Attended school within the census year'),
            new CensusColumnNull($this, 'Read', 'Cannot read'),
            new CensusColumnNull($this, 'Write', 'Cannot write'),
            new CensusColumnBirthPlaceSimple($this, 'BP', 'Place of birth, naming the state, territory, or country'),
            new CensusColumnFatherBirthPlaceSimple($this, 'FBP', 'Place of birth of father, naming the state, territory, or country'),
            new CensusColumnMotherBirthPlaceSimple($this, 'MBP', 'Place of birth of mother, naming the state, territory, or country'),
        ];
    }
1296900
protected function _getCols()
    {
        if (null === $this->_cols) {
            $this->_setupMetadata();
            $this->_cols = array_keys($this->_metadata);
        }
        return $this->_cols;
    }
556048
public function getColumns()
    {
        $columns = ArrayList::create();
        
        foreach ($this->getEnabledChildren() as $child) {
            
            $columns->push(
                ArrayData::create([
                    'Child' => $child,
                    'ColumnClass' => $this->ColumnClass
                ])
            );
            
        }
        
        return $columns;
    }
94502
private function _getColumns()
    {
        $columns = [];
        foreach ($this->_config['columns'] as $data) {
            $columns[] = new Column($data, $this->_config['view_name']);
        }
        return $columns;
    }
852039
def calculate_columns(self):
        """"""

        self.cols = int(math.ceil(len(self.elements) / float(self.rows)))
955284
public function colCount() {
		$count=$this->count();
		if ($this->hasOnlyCols($count))
			return $count;
		if ($count > 0)
			return $this->getItem(0)->count();
		return 0;
	}
1350043
protected function getSortableColumns()
    {
        if ($this->sortableColumns !== null) {
            return $this->sortableColumns;
        }

        $columns = $this->getColumns();
        $sortable = array_filter($columns, function ($column) {
            return $column->sortable;
        });

        return $this->sortableColumns = $sortable;
    }
440973
public function columns()
    {
        if ($this->columns->isEmpty()) {
            $this->columns->push($this->current);
        }

        return $this->columns;
    }
407028
public function columnCount()
    {

        switch ($this->mode) {

            case "mysql":
                $columns = $this->result->field_count;
                break;

            case "postgres":
            case "redshift":
                $columns = pg_num_fields($this->result);
                break;

            case "odbc":
                $columns = odbc_num_fields($this->result);
                break;

            case "sqlite":
                $columns = $this->result->numColumns();
                break;

            case "mssql":
                $columns = mssql_num_fields($this->result);
                break;

            case "mssqlsrv":
                $columns = sqlsrv_num_fields($this->result);
                break;
        }

        if ($columns === false || $columns < 0) {
            throw new \Exception("Failed to get the column count from the result set");
        }

        return $columns;
    }
996116
public function columns() : array
    {
        if ($this->numRows() > 1) {
            return array_map(null, ...$this->samples);
        }

        $n = $this->numColumns();

        $columns = [];

        for ($i = 0; $i < $n; $i++) {
            $columns[] = array_column($this->samples, $i);
        }

        return $columns;
    }
116124
public function getColumns()
    {
        $session = request()->session();
        $key     = $this->key();
        if (!$session->has($key)) {
            return $this->columns;
        }
        $config = $session->get($key);
        foreach ($this->columns as $index => $column) {
            if (!isset($config[$index])) {
                continue;
            }
            $column->visible = $config[$index];
        }

        return $this->columns;
    }