{@inheritDoc}
@see \Jagilpe\EntityListBundle\EntityList\EntityListFactoryInterface::createListColumn()
776378
public function createListColumn($columnName, $listColumnTypeClass = ColumnType::class, array $options = array())
    {
        $listColumnBuilder = $this->createListColumnBuilder($columnName, $listColumnTypeClass, $options);
        return $listColumnBuilder->getListColumn();
    }
1151772
public function createColumnFactory(): ColumnFactory {
		if (!($this->columnFactory)) {
			$this->columnFactory = new MysqlColumnFactory($this);
		}
		return $this->columnFactory;
	}
435376
protected function createColumn($column)
	{
		$c=new CMysqlColumnSchema;
		$c->name=$column['Field'];
		$c->rawName=$this->quoteColumnName($c->name);
		$c->allowNull=$column['Null']==='YES';
		$c->isPrimaryKey=strpos($column['Key'],'PRI')!==false;
		$c->isForeignKey=false;
		$c->init($column['Type'],$column['Default']);
		$c->autoIncrement=strpos(strtolower($column['Extra']),'auto_increment')!==false;
		if(isset($column['Comment']))
			$c->comment=$column['Comment'];

		return $c;
	}
928246
public function addColumn($col)
    {
        if (!$col instanceof Column\AbstractColumn) {
            $col = $this->createColumn($col);
        }

        if (null === $col->getPosition()) {
            $col->setPosition(self::DEFAULT_POSITION);
        }

        $this->columns[$col->getUniqueId()] = $col;
        $this->positions[$col->getPosition()][$col->getUniqueId()] = $col;
    }
1092987
protected function addDefaultListField()
    {
        if (!in_array(Api::API_LIST_NAME_FIELD, array_values($this->extraColumns))) {
            /** @var TableMap $tableMap */
            $tableMap = $this->getTableMap();
            /** @var ColumnMap $column */
            $column = null;
            if ($tableMap->hasColumn('NAME')) {
                $column = $tableMap->getColumn('NAME');
            } elseif ($tableMap->hasColumn('TITLE')) {
                $column = $tableMap->getColumn('TITLE');
            } elseif ($tableMap->hasColumn('LABEL')) {
                $column = $tableMap->getColumn('LABEL');
            }
            if (null !== $column) {
                $this->extraColumns[$column->getFullyQualifiedName()] = Api::API_LIST_NAME_FIELD;
            } else {
                $this->addClassListName($tableMap);
            }
        }
    }
1374811
public static function extendListColumns($callback)
    {
        $calledClass = self::getCalledExtensionClass();
        Event::listen('backend.list.extendColumns', function ($widget) use ($calledClass, $callback) {
            if (!is_a($widget->getController(), $calledClass)) {
                return;
            }
            call_user_func_array($callback, [$widget, $widget->model]);
        });
    }
828820
public function createListObject()
    {
        // Create List Object:
        
        $object = Injector::inst()->create(
            $this->owner->getListComponentClass(),
            $this->owner->getListComponentDefaults()
        );
        
        // Define List Object:
        
        $object->Title = $this->owner->Title;
        $object->HideTitle = 1;
        
        if ($folder = ComponentFolder::find()) {
            $object->ParentID = $folder->ID;
            $object->write();
        }
        
        // Answer List Object:
        
        return $object;
    }
697024
@Override
    protected <T> void buildColumnMappingList(final BeanMapping<T> beanMapping, final Class<T> beanType, final Class<?>[] groups) {
        
        final List<ColumnMapping> columnMappingList = new ArrayList<>();
        for(Field field : beanType.getDeclaredFields()) {
            
            final CsvColumn columnAnno = field.getAnnotation(CsvColumn.class);
            if(columnAnno != null) {
                columnMappingList.add(createColumnMapping(field, columnAnno, groups));
            }
            
        }
        
        beanMapping.addAllColumns(columnMappingList);
        
    }
669410
protected function createColumn(array $fieldData, string $fieldName): ColumnInterface
    {
        $fieldType = $fieldData[self::FIELD_TYPE];

        switch (true) {
            case key_exists($fieldType, $this->fieldClasses[self::COLUMN_SIMPLE]):
                $defaultFieldParameters = $this->parameters[self::COLUMN_SIMPLE];
                $columnClass = $this->fieldClasses[self::COLUMN_SIMPLE][$fieldType];
                break;
            case key_exists($fieldType, $this->fieldClasses[self::COLUMN_LENGTH]):
                $defaultFieldParameters = $this->parameters[self::COLUMN_LENGTH];
                $columnClass = $this->fieldClasses[self::COLUMN_LENGTH][$fieldType];
                break;
            case key_exists($fieldType, $this->fieldClasses[self::COLUMN_PRECISION]):
                $defaultFieldParameters = $this->parameters[self::COLUMN_PRECISION];
                $columnClass = $this->fieldClasses[self::COLUMN_PRECISION][$fieldType];
                break;
            default:
                throw new InvalidArgumentException("Unknown field type: {$fieldType}");
        }

        $args = [];

        foreach ($defaultFieldParameters as $key => $value) {
            if ($key === self::PROPERTY_OPTIONS
                && isset($fieldData[self::FIELD_PARAMS][self::PROPERTY_OPTIONS])
                && key_exists(self::OPTION_AUTOINCREMENT, $fieldData[self::FIELD_PARAMS][self::PROPERTY_OPTIONS])) {
                trigger_error("Autoincrement field is deprecated", E_USER_DEPRECATED);
            }

            if (isset($fieldData[self::FIELD_PARAMS]) && key_exists($key, $fieldData[self::FIELD_PARAMS])) {
                $args[] = $fieldData[self::FIELD_PARAMS][$key];
            } else {
                $args[] = $value;
            }
        }

        array_unshift($args, $fieldName);

        return new $columnClass(...$args);
    }
399265
public function addColumn(Column $column)
    {
        $this->columns[] = $column;

        if ($column instanceof ColumnInterface) {
            $column->initialize($this);
        }

        return $this;
    }
1320636
private function _prepareColumns(): void
    {
        if (method_exists($this->_model, 'toFieldsAmiGrid')) {
            $lists = $this->_model->toFieldsAmiGrid();
        } else {
            $lists = \Schema::getColumnListing($this->_model->getTable());
        }
        if ($this->isVisibleColumn()) {
            $lists = array_diff($lists, $this->_model->getHidden());
        }
        foreach ($lists as $key => $list) {
            $this->column($list, $list)
                ->setDateActive(true)
                ->setSort(true);
        }
        $this->columnActions(function ($data) {
            $buttons = [];
            if ($this->_getConfig('routes')) {
                $pathNameForModel = strtolower(\Illuminate\Support\Str::plural(\Illuminate\Support\Str::camel(class_basename($data))));
                $buttons[] = $this->columnAction()
//                    ->setActionDelete('amigrid.delete', [$pathNameForModel, $data->id])
                    ->setUrl('/' . $pathNameForModel . '/delete')
                    ->setLabel('delete');
                $buttons[] = $this->columnAction()
//                    ->setActionShow('amigrid.show', [$pathNameForModel, $data->id])
                    ->setUrl('/' . $pathNameForModel)
                    ->setLabel('show')
//                    ->setHandler(function ($data) {
//                        return $data->id % 2;
//                    })
                ;
                $buttons[] = $this->columnAction()
//                    ->setActionEdit('amigrid.edit', [$pathNameForModel, $data->id])
                    ->setUrl('/' . $pathNameForModel . '/edit')
                    ->setLabel('edit');
            }

            return $buttons;
        });
        if ($this->_getConfig('routes')) {
            $pathNameForModel = strtolower(\Illuminate\Support\Str::plural(\Illuminate\Support\Str::camel(class_basename($this->_model))));
            $this->button()->setButtonCreate('/' . $pathNameForModel . '/create');
        }
    }
195736
public ColumnList addColumn(IColumn column){
        return this.addColumn(column.family(), column.qualifier(), column.timestamp(), column.value());
    }
647733
public function addColumn(array $data)
    {
        $columnValidation = $this->_validateColumn($data);
        if (is_string($this->_validateColumn($data))) {
            throw new CollectionException('Invalid column data. '.$columnValidation);
        }

        $this->_columns[] = $data;

        return $this;
    }
1154562
protected function _addColumn(Column $column)
    {
        $columnName = $column->getName();
        $columnName = $this->normalizeIdentifier($columnName);

        if (isset($this->_columns[$columnName])) {
            throw SchemaException::columnAlreadyExists($this->getName(), $columnName);
        }

        $this->_columns[$columnName] = $column;
    }
371456
public function createInstance()
    {
        switch ($this->method) {
            case 'addBigIntegerColumn':
            case 'addBinaryColumn':
            case 'addBooleanColumn':
            case 'addDateColumn':
            case 'addDateTimeColumn':
            case 'addDecimalColumn':
            case 'addFloatColumn':
            case 'addIntegerColumn':
            case 'addSmallIntegerColumn':
            case 'addStringColumn':
            case 'addTextColumn':
            case 'addTimeColumn':
                $namespace = 'Rentgen\\Database\\Column\\';
                $class = $namespace . ltrim($this->method, 'add');
                $options = isset($this->params[1]) ? $this->params[1] : array();

                if ('addStringColumn' === $this->method && !isset($options['limit'])) {
                    $options['limit'] = 255;
                }
                $column = new $class($this->params[0], $options);
                break;
            case 'addCustomColumn':
                $options = isset($this->params[2]) ? $this->params[2] : [];
                $column = new CustomColumn($this->params[0], $this->params[1], $options);
                break;
            default:
                throw new \Exception(sprintf("Unsupported method " . $this->method));
        }

        if (isset($options['comment'])) {
            $column->setDescription($options['comment']);
        }

        return $column;
    }
183788
@Override
    public Table addColumns(final Column<?>... cols) {
        for (final Column<?> c : cols) {
            validateColumn(c);
            columnList.add(c);
        }
        return this;
    }
221485
protected function checkSortableColumnHasAttribute(TableListColumn $column): void
    {
        if (! $column->getAttribute('attribute') && $column->getAttribute('isSortableColumn')) {
            $errorMessage = 'One of the sortable columns has no defined attribute. You have to define a column '
                            . 'attribute for each sortable columns by setting a string parameter in the '
                            . '« addColumn() » method.';
            throw new ErrorException($errorMessage);
        }
    }