Moves a set of extra properties from an old to a new node after their IDs have changed.

@param oldNodeId the old identifier for the node; may not be null
@param newNodeId the new identifier for the node; may not be null
17848
protected void moveExtraProperties( String oldNodeId,
                                        String newNodeId ) {
        ExtraPropertiesStore extraPropertiesStore = extraPropertiesStore();
        if (extraPropertiesStore == null || !extraPropertiesStore.contains(oldNodeId)) {
            return;
        }
        Map<Name, Property> existingExtraProps = extraPropertiesStore.getProperties(oldNodeId);
        extraPropertiesStore.removeProperties(oldNodeId);
        extraPropertiesStore.storeProperties(newNodeId, existingExtraProps);
    }
881454
public void addEntityId(long entityId)
    {
        if(this.entityIds == null)
            this.entityIds = new ArrayList<Long>();
        this.entityIds.add(entityId);
    }
1238552
function (node, next) {
                var oldGuid = self.core.getGuid(node),
                    newGuid;
                if (guids.hasOwnProperty(oldGuid)) {
                    hasCollision = true;
                    if (currentConfiguration.checkOnly) {
                        self.createMessage(node, 'guid collision with: ' + guids[oldGuid]);
                    } else {
                        newGuid = GUID();
                        self.core.setGuid(node, newGuid);
                        self.createMessage(node, 'guid changed [' + oldGuid + ']->[' + newGuid + ']');
                        guids[newGuid] = self.core.getPath(node);
                    }
                } else {
                    guids[oldGuid] = self.core.getPath(node);
                }
                next(null);
            }
1022003
public function deleteNode($nodeId)
    {
        $node = $this->getNode($nodeId);

        $operation = new Operations\Delete($node, $this->config, $this);
        $operation->run();
    }
1194949
public static void replaceResourceIds(Element element, String oldId, String newId) {

        NodeList<Element> children = CmsDomUtil.querySelectorAll(
            FIELD_SELECTOR + ENTITY_ID_SELECTOR_PREFIX + oldId + ENTITY_ID_SELECTOR_SUFFIX,
            element);
        if (children.getLength() > 0) {
            for (int i = 0; i < children.getLength(); i++) {
                Element child = children.getItem(i);
                String idData = child.getAttribute(CmsGwtConstants.ATTR_DATA_ID);
                idData = idData.replace(oldId, newId);
                child.setAttribute(CmsGwtConstants.ATTR_DATA_ID, idData);
            }
        }
    }
368102
void wipeDatanode(DatanodeID nodeID) throws IOException {
    String key = nodeID.getStorageID();
    host2DataNodeMap.remove(datanodeMap.remove(key));
    if (NameNode.stateChangeLog.isDebugEnabled()) {
      NameNode.stateChangeLog.debug(
        "BLOCK* NameSystem.wipeDatanode: "
          + nodeID.getName() + " storage " + key
          + " is removed from datanodeMap.");
    }
  }
283135
def _move_node_file(path, old_id, new_id):
    
    root = os.path.join(path, "project-files")
    if os.path.exists(root):
        for dirname in os.listdir(root):
            module_dir = os.path.join(root, dirname)
            if os.path.isdir(module_dir):
                node_dir = os.path.join(module_dir, old_id)
                if os.path.exists(node_dir):
                    shutil.move(node_dir, os.path.join(module_dir, new_id))
398124
public void retainNode(String id) {
        synchronized (retainedNodes) {
            Node current = getCurrentNode();

            if (current != null) {
                retainedNodes.put(id, current);
            }
        }
    }
135718
protected void moveChildNodes(final DOMNode sourceNode, final DOMNode targetNode) {

		DOMNode child = (DOMNode) sourceNode.getFirstChild();

		while (child != null) {

			DOMNode next = (DOMNode) child.getNextSibling();

			targetNode.appendChild(child);

			child = next;

		}

	}
1113163
public function removeNode($nodeId)
    {
        if (isset($this->nodeSet[$nodeId]))
            unset($this->nodeSet[$nodeId]);
        return true;
    }
12743
function removeNode(node, parentNode, skipKeyedNodes) {
            if (onBeforeNodeDiscarded(node) === false) {
                return;
            }

            if (parentNode) {
                parentNode.removeChild(node);
            }

            onNodeDiscarded(node);
            walkDiscardedChildNodes(node, skipKeyedNodes);
        }
1269297
function (prevNode, newNode) {
      if (prevNode === newNode) {
          return;
      }
      TNode.replaceNodeBy.call(this,prevNode, newNode);
      var aen=this.attEltNodes;
      if (aen) {
          for (var i=0,sz=aen.length; sz>i;i++) {
              aen[i].replaceNodeBy(prevNode, newNode);
          }
      }
  }
529294
function (nodeList, newNodes) {
			// Unregister all childNodeLists.
			var oldNodes = nodeLists.unregisterChildren(nodeList);

			newNodes = makeArray(newNodes);

			var oldListLength = nodeList.length;

			// Replace oldNodeLists's contents.
			splice.apply(nodeList, [
				0,
				oldListLength
			].concat(newNodes));

			// Replacements are nodes that have replaced the original element this is on.
			// We can't simply insert elements because stache does children before parents.
			if(nodeList.replacements){
				nodeLists.nestReplacements(nodeList);
				nodeList.deepChildren = nodeList.newDeepChildren;
				nodeList.newDeepChildren = [];
			} else {
				nodeLists.nestList(nodeList);
			}

			return oldNodes;
		}
464400
protected final void firePropertyDataChanged(Collection<? extends D> oldData, Collection<? extends D> newData) {
		firePropertyDataChanged(new TreeDataEvent(this, oldData, newData, this.data));
	}
172264
public Object removeProperty( Object propertyId ) {
        return nodeProperties != null ? nodeProperties.remove(propertyId) : null;
    }
639003
public boolean replaceNode(final Node oldOne, final @Nonnull Node newOne) throws IOException {
        if (oldOne == nodes.get(oldOne.getNodeName())) {
            // use the queue lock until Nodes has a way of directly modifying a single node.
            Queue.withLock(new Runnable() {
                public void run() {
                    Nodes.this.nodes.remove(oldOne.getNodeName());
                    Nodes.this.nodes.put(newOne.getNodeName(), newOne);
                    jenkins.updateComputerList();
                    jenkins.trimLabels();
                }
            });
            updateNode(newOne);
            if (!newOne.getNodeName().equals(oldOne.getNodeName())) {
                Util.deleteRecursive(new File(getNodesDir(), oldOne.getNodeName()));
            }
            NodeListener.fireOnUpdated(oldOne, newOne);

            return true;
        } else {
            return false;
        }
    }
1056858
void setNewNodes() {

        int indexcount = tTable.getIndexCount();

        nPrimaryNode = new NodeAVLDisk(this, 0);

        NodeAVL n = nPrimaryNode;

        for (int i = 1; i < indexcount; i++) {
            n.nNext = new NodeAVLDisk(this, i);
            n       = n.nNext;
        }
    }