Will create the final ColumnConfiguration

@return ColumnConfiguration
486224
public function build()
    {
        $this->checkName();
        $this->checkCallable();
        $this->checkOrderable();
        $this->checkSearchable();

        return new ColumnConfiguration($this->name, $this->callable, $this->searchable, $this->orderable);
    }
1204342
public function create()
    {
        /**
         * @var ConfigurationInterface $configuration
         */
        $classNamespace = $this->getEntityNamespace();
        $configuration = new $classNamespace();

        $configuration
            ->setNamespace('')
            ->setType(ElcodiConfigurationTypes::TYPE_STRING)
            ->setCreatedAt($this->now());

        return $configuration;
    }
717604
protected function makeConfig() {
        $this->_checkConfig();

        // Construct the DBConfig object
        $ftpConfig = new FtpConfig();
        $ftpConfig->setHost($this->_config['host']);
        $ftpConfig->setPort($this->_config['port']);
        $ftpConfig->setUser($this->_config['user']);
        $ftpConfig->setPrivateKey($this->_baseDir.'/'.$this->_config['private_key']);
        $ftpConfig->setPublicKey($this->_baseDir.'/'.$this->_config['public_key']);

        return $ftpConfig;
    }
1098378
private function constructColumnHeaders()
    {
        foreach ($this->columnHeaders as $column_name => $column_key) {
            $this->columnHeaderObjects[] = new TableColumnHeader(
                $this,
                $this->request,
                $column_key,
                $column_name
            );
        }
    }
763178
protected function createClass()
	{
		$cols = $this->numOfColumns;
		if ($cols === self::COLUMNS_NONE) {
			return 'col';
		} elseif ($cols === self::COLUMNS_AUTO) {
			return 'col-auto';
		} else {
			// number
			if ($this->row->gridBreakPoint != NULL) {
				return 'col-' . $this->row->gridBreakPoint . '-' . $this->numOfColumns;
			} else {
				return 'col-' . $this->numOfColumns;
			}
		}
	}
1076782
protected function createColumn($key, array $columnConfiguration)
    {
        if ($this->translator) {
            $columnConfiguration['translator'] = $this->translator;
        }
        $this->columns[] = new Column($key, $this, $columnConfiguration);
    }
523568
public function getColumnOptions()
    {
        // Create Options Array:
        
        $options = [];
        
        // Merge Template Columns:
        
        if ($template = $this->getPageTemplate()) {
            
            foreach ($template->getAllComponentsByClass(Column::class) as $column) {
                $options[$column->ID] = $this->getColumnLabel($column, $template);
            }
            
        }
        
        // Merge Layout Columns:
        
        if ($layout = $this->getPageLayout()) {
            
            foreach ($layout->getAllComponentsByClass(Column::class) as $column) {
                $options[$column->ID] = $this->getColumnLabel($column, $layout);
            }
            
        }
        
        // Answer Options Array:
        
        return $options;
    }
313822
private function buildFieldColumnDescription()
    {
        if (!$info = entity_get_info($this->entityType)) {
            throw new ConfigurationError(sprintf("entity type '%s' does not exist", $this->entityType));
        }

        $idColumn = $info['entity keys']['id'];
        $done = [];

        foreach (array_keys($info['bundles']) as $bundle) {
            if (!$instances = field_info_instances($this->entityType, $bundle)) {
                continue;
            }

            foreach ($instances as $fieldName => $instance) {

                // Avoid doing the same field twice
                if (isset($done[$fieldName])) {
                    continue;
                }
                $done[$fieldName] = true;

                // Ensure field exists
                if (!$field = field_info_field($fieldName)) {
                    continue;
                }
                // We cannot proceed with multiple values, for now, without
                // using group by on those
                // @todo handle this gracefully
                if (1 !== (int)$field['cardinality']) {
                    continue;
                }
                // Do not use deleted fields, or non SQL handled fields
                if ($field['deleted'] || 'field_sql_storage' !== $field['storage']['type']) {
                    continue;
                }

                $table = _field_sql_storage_tablename($field);
                // @todo handle conflicts
                if ('field_' === substr($fieldName, 0, 6)) {
                    $tableAlias = substr($fieldName, 6);
                } else {
                    $tableAlias = $fieldName;
                }

                $this->joins[$tableAlias] = [
                    'type'      => 'LEFT',
                    'table'     => $table,
                    'condition' => sprintf(
                        "%s.entity_type = '%s' AND %s.entity_id = base.%s",
                        $tableAlias, $this->entityType, $tableAlias, $idColumn
                    )
                ];

                foreach ($field['columns'] as $name => $description) {
                    $column = _field_sql_storage_columnname($fieldName, $name);
                    $columnAlias = $tableAlias.'_'.$name;

                    if (!empty($instance['label'])) {
                        $label = $instance['label'];
                    } else if (!empty($description['description'])) {
                        $label = $description['description'];
                    } else {
                        $label = $fieldName;
                    }

                    $this->fields[$columnAlias] = [
                        'label'   => $label,
                        'column'  => $tableAlias.'.'.$column,
                        'choices' => null,
                    ];
                }
            }
        }
    }
896090
public function build()
    {
        $mapping = $this->mapping;
        if ($this->joinColumns) {
            $mapping['joinColumns'] = $this->joinColumns;
        }
        $cm = $this->builder->getClassMetadata();
        if ($this->type == ClassMetadata::MANY_TO_ONE) {
            $cm->mapManyToOne($mapping);
        } else if ($this->type == ClassMetadata::ONE_TO_ONE) {
            $cm->mapOneToOne($mapping);
        } else {
            throw new \InvalidArgumentException("Type should be a ToOne Association here");
        }
        return $this->builder;
    }
692632
public function getColumn()
    {
        $type = $this->getSqlType();
        if ($type) {
            return new Column($this->getAttributeName(), $type, $this->getSqlOptions());
        }
    }
429705
protected function prependRowSelectorColumn()
    {
        if (!$this->option('useRowSelector')) {
            return;
        }

        $grid = $this;

        $column = new Column(Column::SELECT_COLUMN_NAME, ' ');
        $column->setGrid($this);

        $column->display(function ($value) use ($grid, $column) {
            $actions = new RowSelector($value, $grid, $column, $this);

            return $actions->display();
        });

        $this->columns->prepend($column);
    }
646242
public function removeColumn()
    {
        $names                     = func_get_args();
        $this->columnDef['excess'] = array_merge($this->columnDef['excess'], $names);

        return $this;
    }
107832
public function create()
	{
		// Element fields, so don´t use parent construct method
		$GLOBALS['TL_DCA']['tl_content']['palettes'][$this->element] .= ',invisible';
		$GLOBALS['TL_DCA']['tl_content']['fields']['invisible']['eval']['tl_class'] = 'clr'; // push to new row (clear)
	
		// The start field
		if ($this->canChangeStart)
		{
			$GLOBALS['TL_DCA']['tl_content']['palettes'][$this->element] .= ',start';
		}
		// The stop field
		if ($this->canChangeStop)
		{
			$GLOBALS['TL_DCA']['tl_content']['palettes'][$this->element] .= ',stop';
		}		
	}
1050997
public JoinColumn<ManyToOne<T>> getOrCreateJoinColumn()
   {
      List<Node> nodeList = childNode.get("join-column");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new JoinColumnImpl<ManyToOne<T>>(this, "join-column", childNode, nodeList.get(0));
      }
      return createJoinColumn();
   }
653107
protected function initColumns()
    {
        foreach ($this->columns as $i => $column) {
            $definition = array_merge([
                'class'         => $this->columnClass,
                'renderer'      => $this,
                'context'       => $this->context,
            ], $column);

            $this->addButtonOptions = (array)$this->addButtonOptions;

            if (!isset($definition['attributeOptions'])) {
                $definition['attributeOptions'] = $this->attributeOptions;
            }

            if (!isset($definition['enableError'])) {
                $definition['enableError'] = $this->enableError;
            }

            $this->columns[$i] = Yii::createObject($definition);
        }
    }
382270
public function make()
    {
        // empty table to start
        $table = [];
        // get the max length of each column in the table
        $field_lengths = $this->maxMultidimensionalArrayStringSize($this->data);
        // get the length of a row by mocking up a row
        $row_length = $this->calculateRowLength($field_lengths, $this->seperator_padding, $this->seperator);
        // get the top and bottom of the table
        $book_end = $this->su->fill($row_length, $this->header_character);
        // get the row that appears below the header row to seperate it from the other rows
        $below_header = $this->su->fill($row_length, $this->below_header_character);
        // add the top $book_end
        $table[] = $book_end;
        // loop over each 'row' in our array
        for ($i = 0; $i < count($this->data); $i++) {
            // line starts as just the left most seperator
            $line = $this->seperator . $this->su->fill($this->seperator_padding);
            // loop over each 'field' aka column in our row
            for ($j = 0; $j < count($this->data[$i]); $j++) {
                // format the fields such that they have a max length of the biggest field in this column
                // and add the additional padding, then pass this to the formatter method and append it to
                // the line and then add the seperator
                $line .= $this->su->{$this->formatter}($this->data[$i][$j], $field_lengths[$j]) . $this->su->fill($this->seperator_padding) . $this->seperator . $this->su->fill($this->seperator_padding);
            }
            // add the new line to the table
            $table[] = $line;
            // if this was the first row we will add a $below_header row to break it up
            if ($i == 0) {
                $table[] = $below_header;
            }
        }
        // add the bottom book end to the table
        $table[] = $book_end;
        // set the table data on the instance
        $this->table = $table;
        return $this;
    }
1151772
public function createColumnFactory(): ColumnFactory {
		if (!($this->columnFactory)) {
			$this->columnFactory = new MysqlColumnFactory($this);
		}
		return $this->columnFactory;
	}