Sets the name of this `XMLElement`, ie. 'p' => <p />

@since Symphony 2.3.2
@param string $name
The name of the `XMLElement`, 'p'.
@param boolean $createHandle
Whether this function should convert the `$name` to a handle. Defaults to
`false`.
491885
public function setName($name, $createHandle = false)
    {
        $this->_name = ($createHandle) ? Lang::createHandle($name) : $name;
    }
242951
static function setProcessName($name)
    {
        if (function_exists('cli_set_process_title'))
        {
            @cli_set_process_title($name);
        }
        else
        {
            if (function_exists('swoole_set_process_name'))
            {
                @swoole_set_process_name($name);
            }
            else
            {
                trigger_error(__METHOD__ . " failed. require cli_set_process_title or swoole_set_process_name.");
            }
        }
    }
281485
public function setName($name)
    {
        if ($this->getMultiValue() === true) {
            $name .= $this->getMultiValueSuffix();
        }

        return parent::setName($name);
    }
1086551
public function offsetSet($name, $value)
    {
        if ($value instanceof Element) {
            parent::offsetSet($name, $value);
        } else {
            $meta = $this->ownerDocument->createElement($this->element);
            $meta->setAttribute($name, $value);

            parent::offsetSet($name, $meta);
        }
    }
804776
public function setName($name)
    {
        if ($this->overrideName) {
            throw new Forbidden('This node cannot be renamed');
        }

        list($parentPath) = Uri\split($this->path);
        list(, $newName) = Uri\split($name);

        $newPath = $parentPath.'/'.$newName;
        rename($this->path, $newPath);

        $this->path = $newPath;
    }
850796
public function setName($name)
    {
        $this->name = $name;
        if ($this->node) {
            $this->node->name = $name;
        }
    }
472479
private function addElement($name, $parent = false, $ns = false)
    {
        if ($ns) {
            $el = $this->doc->createElementNS($ns, $name);
        } else {
            $el = $this->doc->createElement($name);
        }
        if ($parent) {
            $parent->appendChild($el);
        }

        return $el;
    }
659281
public function setName($name)
    {
        $nameParts = explode(' ', $name);
        $this->Surname = array_pop($nameParts);
        $this->FirstName = join(' ', $nameParts);
    }
209426
public function setNewlineTokenName(string $name) : BasicLexer
    {
        if (strlen($name) == 0) {
            throw new \InvalidArgumentException('The name of the newline token must be not empty.');
        }

        $this->newlineTokenName = $name;

        return $this;
    }
1126561
function XElement(name) {
        _super.call(this);
        this._elements = new observable_array_1.ObservableArray();
        if (!(name instanceof XName)) {
            name = new XName(name);
        }
        this._name = name;
    }
609301
private function CreateNamespace(&$name)
    {
        if($name == "")
            $name = "\\";

        if(!isset($this->namespaces[$name]))
            $this->namespaces[$name] = new NamespaceElement($name);
    }
350843
public void assignName(XAttributable element, String name) {
		if (name != null && name.trim().length() > 0) {
			XAttributeLiteral attr = (XAttributeLiteral) ATTR_NAME.clone();
			attr.setValue(name);
			element.getAttributes().put(KEY_NAME, attr);
		}
	}
475867
public function setName($name)
    {
        list($domain, $locale, $extention) = explode('.', $name);

        $this->domain = $domain;
        $this->locale = $locale;
        $this->extention = $extention;
    }
756263
private static boolean setName(String ns, String name, Schema property) {
        boolean apply = false;
        final String cleanName = StringUtils.trimToNull(name);
        final String useName;
        if (!isEmpty(cleanName) && !cleanName.equals(((SchemaImpl) property).getName())) {
            useName = cleanName;
            apply = true;
        } else {
            useName = null;
        }
        final String cleanNS = StringUtils.trimToNull(ns);
        final String useNS;
        if (!isEmpty(cleanNS)) {
            useNS = cleanNS;
            apply = true;
        } else {
            useNS = null;
        }
        // Set everything or nothing
        if (apply) {
            getXml(property).name(useName).namespace(useNS);
        }
        return apply;
    }
416859
public function setName($name)
    {
        if (!is_string($name) || (strlen($name) <= 0)) {
            $explodedNamespace = explode('\\', get_class($this));
            $class = $explodedNamespace[count($explodedNamespace) - 1];
            $asset = strtolower(preg_replace('/(.)([A-Z])/', '\\1 \\2', $class));

            throw SchemaException::invalidAssetName($asset);
        }

        $this->name = $name;
    }
1277179
public function setElement($name, $element, $position = null)
    {
        $name = trim($name);
        if ($name === '') {
            throw new InvalidArgumentException('Empty child name');
        } elseif (is_array($element)) {
            $config = $element;
            $config['parent'] = $this;
            $config['name'] = $name;
            $element = $this->createElement($config);
        } elseif (true === ($element instanceof \marvin255\serviform\interfaces\Field)) {
            $element->setName($name);
            $element->setParent($this);
        } else {
            throw new InvalidArgumentException('Wrong child type for field: ' . $name);
        }
        if ($position === null) {
            $this->elements[$name] = $element;
        } else {
            $elements = [];
            $itemPosition = $position < 0 ? count($this->elements) + $position : $position;
            $i = 0;
            foreach ($this->elements as $iKey => $iElement) {
                if ($i === $itemPosition) {
                    $elements[$name] = $element;
                }
                $elements[$iKey] = $iElement;
                ++$i;
            }
            $this->elements = $elements;
        }

        return $this;
    }
629777
public function setName(string $name) : void
    {
        if (empty($name)) {
            throw new InvalidArgumentException('Empty field name is not allowed');
        }

        $this->_name = $name;
    }