Creates a procedure.

@param string $name Procedure name

@return $this
85
public function createProcedure($name)
    {
        $definition = array(
            'parent' => $this->context,
            'name' => $name,
            'sources' => array(),
            'workers' => array(),
            'targets' => array(),
            'children' => array(),
        );

        $this->definitions[$name] = $definition;

        $this->context = $name;

        return $this;
    }
456591
public function create($name)
    {
        $class = $this->class;
        /** @var Group $group */
        $group = new $class($name, $this->dispatcher);
        $this->groups[$group->getName()] = $group;

        return $group;
    }
395752
public function rename(string $name) : self
    {
        $this->requiresCurrentField();
        $this->newObj['$rename'][$this->currentField] = $name;
        return $this;
    }
1018682
public function using(string $name): self
    {
        if (!isset($this->providers[$name])) {
            throw ProviderNotRegistered::create($name ?? '', $this->providers);
        }

        $this->provider = $this->providers[$name];

        return $this;
    }
483611
public function provider($name)
    {
        $slice = $this->slice->getSlice($name);

        $type  = $slice->getRequired('type');
        $class = $this->mapClasses[$type];

        return new $class($this, $slice);
    }
906213
public function create($name){
        $this->menuCollection[$name] = new MenuCollection;
        $this->menuCollection[$name]->setName($name);

        return $this->menuCollection[$name];
    }
1203912
final public function setName($name): Command
    {
        if (!$this->namespace) {
            parent::setName($name);
            return $this;
        }
        parent::setName(sprintf('%s:%s', $this->namespace, $name));
        return $this;
    }
422134
public function createPalette($name = null)
    {
        if ($this->palette) {
            $this->finishPalette();
        }

        $palette = $this->paletteClass->newInstance();

        if ($name) {
            $palette->setName($name);
        }

        $event = new CreatePaletteEvent($palette, $this);
        $this->dispatchEvent($event);
        $this->palette = $event->getPalette();

        return $this;
    }
13272
public function setName($name)
    {
        $this->validateName($name);

        if (!$this->name) {
            $this->name = $name;
        } elseif ($this->name !== $name) {
            $this->setAliases([$name]);
        }
        return $this;
    }
1078243
private function createMethod(string $name): MethodInterface
    {
        $class = 'Ekyna\\Component\\Dpd\\EPrint\\Method\\' . ucwords($name);
        if (class_exists($class)) {
            /** @var MethodInterface $instance */
            return new $class($this->getClient());
        }

        throw new RuntimeException("Method {$name} does not exist");
    }
741702
public function setName($name) {
        if (!is_string($name)) throw new IllegalTypeException('Illegal type of parameter $name: '.gettype($name));
        if (!strlen($name))    throw new InvalidArgumentException('Invalid argument $name: '.$name);

        $this->name = $name;
        return $this;
    }
1354960
public static function duplicate(string $name): self
    {
        $e = sprintf(self::DUPLICATE, $name);

        return new static($e);
    }
815529
final public static function createByName(string $name)
    {
        $canonicalName = strtoupper($name);
        if ($canonicalName !== $name) {
            $name = $canonicalName;
            trigger_error('PSR-1 requires constant to be declared in upper case.', E_USER_NOTICE);
        }

        $const = static::getConstList();

        if (!\in_array($name, $const, true)) {
            throw EnumException::becauseUnknownMember(static::class, $name);
        }

        return static::createNamedInstance($name);
    }
888970
public function create($name)
	{
		$model = Bauhaus::getInstance($name)->buildForm();

		return View::make($model->getView('create'))
			->with('name',  $name)
			->with('model', $model);
	}
278188
public function create(string $name)
    {
        $className = $this->getClassName($name);

        $result = $this->createInstance($className);

        return $result;
    }
137
protected function createComponent($name): ?IComponent
    {
        $method = 'createComponent'.ucfirst($name);
        if (method_exists($this, $method)) {
            $this->checkRequirements(self::getReflection()->getMethod($method));
        }

        return parent::createComponent($name);
    }
683638
public function create($name)
    {
        $this->checkName($name);

        $configuration = new Configuration();

        $configuration->setName($name);

        $configuration->setModel($this->getParameter($name, 'model'));
        $configuration->setForm($this->getParameter($name, 'form'));
        $configuration->setFormTemplate($this->getParameter($name, 'template.form'));
        $configuration->setRecipientTemplate($this->getParameter($name, 'template.recipient'));
        $configuration->setRecipient($this->getParameter($name, 'recipient'));
        $configuration->setConfirmTemplate($this->getParameter($name, 'template.confirm'));
        $configuration->setPageTemplate($this->getParameter($name, 'template.page'));
        $configuration->setFrom($this->getParameter($name, 'from'));
        $configuration->setSenderName($this->getParameter($name, 'sender_name'));
        $configuration->setSubject($this->getParameter($name, 'subject'));
        $configuration->setTranslationDomain($this->getParameter($name, 'translation_domain'));
        $configuration->setConfirmMail($this->getParameter($name, 'confirm_mail'));

        return $configuration;
    }