Renames the configured property to the new name.

@param NodeData $node
@return void
343907
public function execute(NodeData $node)
    {
        $node->setProperty($this->newPropertyName, $node->getProperty($this->oldPropertyName));
        $node->removeProperty($this->oldPropertyName);
    }
1177844
public void setNodeData(byte[] nodeData)
    {
        this.nodeData = (nodeData != null) ? Arrays.copyOf(nodeData, nodeData.length) : null;
    }
725102
public function rename($oldName, $newName)
	{
		$form = $this->get($oldName);
		$this->delete($oldName);
		$this->add($newName, $form['code'], $form['title']);
	}
929722
public function rename($oldname, $newname) {
		$this->connectIfNeeded();
		$this->handle->rename($oldname, $newname);
		$this->onFileRenamed(
			new Event(['sender' => $this, 'data' => [
				'oldname' => $oldname, 
				'newname' => $newname
			]])
		);
	}
187403
def rename_node(self, prefix):
        
        node_map_dict = {}
        # map each node to its new name (e.g. "a1")
        for i in range(0, len(self.nodes)):
            node_map_dict[self.nodes[i]] = prefix + str(i)
        # update node name
        for i, v in enumerate(self.nodes):
            self.nodes[i] = node_map_dict[v]
        # update node name in relations
        for node_relations in self.relations:
            for i, l in enumerate(node_relations):
                node_relations[i][1] = node_map_dict[l[1]]
430683
def rename(self, node):
        
        child_object = self.translate(node.child)
        from_block = '({child}) AS {name}({attributes})'.format(
            child=child_object.to_sql(), name=node.name,
            attributes=', '.join(node.attributes.names))
        return self.query(str(node.attributes), from_block=from_block)
709949
protected function normalizeNode(DOMNode $node)
	{
		if (!$node->parentNode)
		{
			// Ignore nodes that have been removed from the document
			return;
		}
		if ($node instanceof DOMElement)
		{
			$this->normalizeElement($node);
		}
		elseif ($node instanceof DOMAttr)
		{
			$this->normalizeAttribute($node);
		}
	}
508976
public function enterNode(Node $node): void
    {
        $name = null;

        if ($node instanceof Name) {
            $name = $node->toString();
        }

        if ($name === null
            || (array_key_exists($name, $this->symbols)
                && $this->symbols[$name] === false
            )
        ) {
            return;
        }

        if (!$this->filter->__invoke($name)) {
            $this->symbols[$name] = false;
            return;
        }

        if (!array_key_exists($name, $this->symbols)) {
            $this->symbols[$name] = [];
        }

        $this->symbols[$name][] = $node;
    }
730390
def rename(self, node):
        

        source = node.path
        base_name, state = QInputDialog.getText(self, "Rename", "Enter your new name:", text=os.path.basename(source))
        if not state:
            return False

        base_name = foundations.strings.to_string(base_name)
        if base_name == os.path.basename(source):
            return False

        parent_directory = os.path.dirname(source)
        target = os.path.join(parent_directory, base_name)

        if self.__script_editor.model.is_authoring_node(node):
            if not foundations.common.path_exists(source):
                LOGGER.info("{0} | Renaming '{1}' untitled file to '{2}'!".format(
                    self.__class__.__name__, source, target))
                self.__set_authoring_nodes(source, target)
                return True

        if not base_name in os.listdir(parent_directory):
            if node.family == "File":
                LOGGER.info("{0} | Renaming '{1}' file to '{2}'!".format(self.__class__.__name__, source, target))
                self.__rename_file(source, target)
            elif node.family == "Directory":
                LOGGER.info("{0} | Renaming '{1}' directory to '{2}'!".format(self.__class__.__name__, source, target))
                self.__rename_directory(source, target)
            elif node.family == "Project":
                LOGGER.info("{0} | Renaming '{1}' project to '{2}'!".format(self.__class__.__name__, source, target))
                self.__rename_project(source, target)
        else:
            self.__raise_file_system_exception(base_name, parent_directory)

        return True
1017676
public function add_node(node $node) {
        $name = $node->name;
        if (isset($this->nodes[$name])) {
            throw new \coding_exception("Node name $name already used");
        }
        $this->nodes[$node->name] = $node;
    }
562679
protected function applyAttributes(&$data, &$node)
    {
        if(isset($data['@attrib']))
        {
            foreach($data['@attrib'] as $key => $value)
            {
                if(true === $this->isValidElementName($key))
                {
                    $value = $this->getBooleanAsString($value);

                    $node->setAttribute($key, $value);
                }
                else
                {
                    throw new InvalidArgumentException(
                        sprintf('Illegal character in attribute (%s) name', $key)
                    );
                }
            }

            unset($data['@attrib']);
        }
    }
714465
protected void doRename(final ItemData item, final WorkspaceStorageConnection con, final Set<QPath> addedNodes)
      throws RepositoryException, InvalidItemStateException
   {
      final NodeData node = (NodeData)item;

      checkSameNameSibling(node, con, addedNodes);
      addedNodes.add(node.getQPath());

      con.rename(node);
   }
629541
public synchronized void rename(String oldName, String newName) throws IOException {
        boolean touched = false;
        if (original != null) {
            if (original.getName().equals(oldName)) {
                original.setName(newName);
                touched = true;
            }
        }
        
        if (usages != null) {
            RangeSet r = usages.get(oldName);
            if (r != null) {
                usages.put(newName, r);
                usages.remove(oldName);
                touched = true;
            }
        }
        
        if (touched) {
            save();
        }
    }
778876
public function setProperty(NodeInterface $node, \DOMElement $element) : void
    {
        if ($node instanceof ItemInterface) {
            $author = $node->newAuthor();
            $author->setName($element->nodeValue);
            $node->setAuthor($author);
        }
    }
339514
public function execute(NodeData $node)
    {
        $currentPropertyValue = $node->getProperty($this->propertyName);
        $newValueWithReplacedCurrentValue = str_replace($this->currentValuePlaceholder, $currentPropertyValue, $this->newValue);
        $newValueWithReplacedSearch = str_replace($this->search, $this->replace, $newValueWithReplacedCurrentValue);
        $node->setProperty($this->propertyName, $newValueWithReplacedSearch);
    }
833732
protected function setAsShadowOf(NodeData $nodeData = null)
    {
        $this->setMovedTo($nodeData);
        $this->setRemoved(($nodeData !== null));
        $this->addOrUpdate();
    }
465442
public function setProperty(NodeInterface $node, \DOMElement $element) : void
    {
        $node->setTitle($element->nodeValue);
    }