@param string $name

@throws InvalidArgumentException

@return Column
426921
final public function getColumn(string $name): Column
    {
        if (!array_key_exists($name, $this->columns)) {
            throw new InvalidArgumentException('Column '.$name.' not added');
        }

        return $this->columns[$name];
    }
458885
public function getColumn($name)
    {
        $columnValues = array();
        foreach ($this->getRows() as $row) {
            $columnValues[] = $row->getColumn($name);
        }
        return $columnValues;
    }
1222607
public function getConfigurator(string $name): FieldSetConfigurator
    {
        if (!isset($this->configurators[$name])) {
            if (isset($this->serviceIds[$name])) {
                $configurator = $this->container->get($this->serviceIds[$name]);
            } elseif (class_exists($name)) {
                // Support fully-qualified class names.
                $configurator = new $name();
            } else {
                throw new InvalidArgumentException(sprintf('Could not load FieldSet configurator "%s".', $name));
            }

            if (!$configurator instanceof FieldSetConfigurator) {
                throw new InvalidArgumentException(sprintf('Configurator class "%s" is expected to be an instance of '.FieldSetConfigurator::class, $name));
            }

            $this->configurators[$name] = $configurator;
        }

        return $this->configurators[$name];
    }
1290499
public function createColumn($name, $type = null, array $options = [])
    {
        $this->preventIfLocked();

        if (null !== $type) {
            return $this->getFactory()->createColumnBuilder($name, $type, $options);
        }

        throw new \InvalidArgumentException('Column type guessing is not yet supported.');
        // TODO return $this->getFormFactory()->createBuilderForProperty($this->getDataClass(), $name, $options);
    }
212881
public function removeColumn($name)
    {
        $this->columns = array_values(array_filter($this->columns, function($c) use ($name)
        {
            return $c['attributes']['name'] != $name;
        }));

        return $this;
    }
639274
public static function name(string $name) : ColumnLabelBuilder
    {
        $self       = new self();
        $self->name = $name;

        return new ColumnLabelBuilder($self);
    }
476916
public static function incrementingInt(string $name) : Column
    {
        return new Column($name, self::primaryKeyType()->autoIncrement(), true);
    }
311813
protected function ensureParameter($name)
    {
        if (!isset($this->$name)) {
            throw new \InvalidArgumentException(get_class($this) . ' is missing parameter: ' . $name);
        }

        return $this->$name;
    }
563965
public function getColumn($name, $alias = '')
    {
        $column = new DerivedColumn($name, $alias);

        return $column->setTable($this);
    }
289790
public function addColumn($column)
    {
        if (is_string($column) && class_exists($column)) {
            $column = new $column();
        }

        if (!$column instanceof Column) {
            throw new \InvalidArgumentException(__METHOD__ . ' argument 1 need Column instance.');
        }

        $this->columns[$column->getName()] = $column;

        return $column;
    }
544022
public function getColumn($name)
    {
        if (!$this->hasColumn($name)) {
            throw SchemaException::tableColumnDoesNotExist($this->getName(), $name);
        }

        return $this->columns[$name];
    }
658446
public function getColumn($name)
    {
        if ($name instanceof AnDomainResourceColumn) {
            return $name;
        }

        if (strpos($name, '.') !== false) {
            $parts = explode('.', $name, 2);
            $name = $parts[1];
            foreach ($this->_resources as $resource) {
                if ($resource->getAlias() == $parts[0]) {
                    break;
                }
            }
            $resources = array($resource);
        } else {
            $resources = $this->_resources;
        }

        foreach ($resources as $resource) {
            if ($resource->hasColumn($name)) {
                return $resource->getColumn($name);
            }
        }

        //throw new AnException('Column '.$name.' doesn\'t exists');
    }
448676
public static function serviceClassname($name)
    {
        $services = static::services();

        if (!isset($services[$name])) {
            throw new \InvalidArgumentException(
                sprintf('The provided service %s does not exist.', $name)
            );
        }

        return $services[$name];
    }
1243010
public static function fromName($name)
    {
        $names = static::getNames();
        if (array_key_exists($name, $names)) {
            return new static($name, $names[$name]);
        }
        throw new \InvalidArgumentException("No enum constant '$name' in class " . get_called_class());
    }
1057523
public function getOption($name) {
        if(!isset($this->options[$name])){
            throw new InvalidArgumentException(sprintf("The option name '%s' is invalid, available are %s.",$name, implode(",",array_keys($this->options))));
        }
        return $this->options[$name];
    }
361765
public function getColumn(string $name)
    {
        if (!isset($this->fields[$name])) {
            Throw new ColumnException(sprintf('A field named "%s" does not exist in this table', $name));
        }

        return $this->fields[$name];
    }
570182
public function getArgument($name)
    {
        if (!$this->hasArgument($name)) {
            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
        }

        $arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;

        return $arguments[$name];
    }