Resets this object with the node held by {@code newNode}.
if {@code newNode} was owning the node, ownership is
transfered to this object.
434735
public void reset(AccessibilityNodeInfoRef newNode) {
        reset(newNode.get());
        mOwned = newNode.mOwned;
        newNode.mOwned = false;
    }
1100565
public void reset() {
    w.lock();
    try {
      for (JedisPool pool : nodes.values()) {
        try {
          if (pool != null) {
            pool.destroy();
          }
        } catch (Exception e) {
          // pass
        }
      }
      nodes.clear();
      slots.clear();
    } finally {
      w.unlock();
    }
  }
1171745
public function reset()
    {
        $this->isNew = true;
        $this->nodesMap = array();
        $this->relationshipsMap = array();
        $this->nodesByLabel = array();
        $this->result = new Result();
    }
1200315
public void clear() throws IOException {
    try {
      zooKeeper.setData(fullyQualifiedZNode, null, expectedZNodeVersion.get());
    } catch (KeeperException.BadVersionException e) {
      LOG.error(fullyQualifiedZNode + " has been updated by another process",
          e);
      throw new StaleVersionException(fullyQualifiedZNode +
          "has been updated by another process!");
    } catch (KeeperException e) {
      keeperException("Unrecoverable ZooKeeper error clearing " +
          fullyQualifiedZNode, e);
    } catch (InterruptedException e) {
      interruptedException("Interrupted clearing " + fullyQualifiedZNode, e);
    }
  }
864793
public final void reset() {
      if (trace) {
         log.tracef("Resetting Node Scope Statistics");
      }
      globalContainer.reset();
      percentiles = new EnumMap<>(PercentileStatistic.class);
      for (PercentileStatistic percentileStatistic : PercentileStatistic.values()) {
         percentiles.put(percentileStatistic, new ReservoirSampler());
      }
   }
1174675
public function clear()
    {
        if (null !== $this->aStructureNode) {
            $this->aStructureNode->removeKstruktur($this);
        }
        if (null !== $this->aSkillRelatedBySkillId) {
            $this->aSkillRelatedBySkillId->removeKstrukturRelatedBySkillId($this);
        }
        $this->id = null;
        $this->type = null;
        $this->skill_id = null;
        $this->title = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
554727
@Override
    protected void nodeRecovered(Node node) {
        NodeStatus nodeStatus = getNodeStatus(node);

        synchronized(nodeStatus) {
            nodeStatus.resetCounters(getConfig().getTime().getMilliseconds());
            super.nodeRecovered(node);
        }
    }
1112205
function( nodeStructure, id, parentId, tree, stackParentId ) {
        this.reset( nodeStructure, id, parentId, tree, stackParentId );
    }
302818
function(node) {
			var newNode = node.cloneNode(true);
			if(this.hasAttribute(node, 'id')){
				this.removeAttribute(node, 'id')
			}
			return newNode;
		}
1126053
void reset(
    Object        key)
  {
    _nodeKey[0] = key;
    _nodeKey[midPoint()] = key;
    _population = 1;
    _rightChild = null;
    _leftChild = null;
    _balance = 0;
  }
211184
public final void reset() {
                for (int i = 0; i < position.length; i++) {
                        position[i] = i;
                }
                permLeft = new BigInteger(permTotal.toString());
        }
850973
def reset(self):
		
		self.gametree = self.game
		self.nodenum = 0
		self.index = 0
		self.stack = []
		self.node = self.gametree[self.index]
		self._setChildren()
		self._setFlags()
917409
public boolean insertBefore(final Node newNode, final Node oldNode) {
        if (oldNode == null || newNode == null) {
            return false;
        }

        int index = nodes.indexOf(oldNode);
        if (index != -1) {
            // Remove the parent from the new node if one exists
            if (newNode.getParent() != null) {
                newNode.removeParent();
            }
            newNode.setParent(this);
            // Add the node to the relevant list
            if (newNode instanceof Level) {
                levels.add((Level) newNode);
            } else if (newNode instanceof SpecTopic) {
                topics.add((SpecTopic) newNode);
            }
            // Insert the node
            if (index == 0) {
                nodes.addFirst(newNode);
            } else {
                nodes.add(index - 1, newNode);
            }
            return true;
        } else {
            return false;
        }
    }
480286
public void add(final T node) {
        if ( this.firstNode == null ) {
            this.firstNode = node;
            this.lastNode = node;
        } else {
            this.lastNode.setNext( node );
            node.setPrevious( this.lastNode );
            this.lastNode = node;
        }
        this.size++;
    }
424067
public void resetLabels() {
        AbstractInsnNode insn = first;
        while (insn != null) {
            if (insn instanceof LabelNode) {
                ((LabelNode) insn).resetLabel();
            }
            insn = insn.next;
        }
    }
615002
public void update(int node) {
        final int prev = prev(node);
        final int next = next(node);
        if ((prev == NIL || compare(prev) > 0) && (next == NIL || compare(next) < 0)) {
            // Update can be done in-place
            copy(node);
            for (int n = node; n != NIL; n = parent(n)) {
                fixAggregates(n);
            }
        } else {
            // TODO: it should be possible to find the new node position without
            // starting from scratch
            remove(node);
            add();
        }
    }
768866
@Override public void reset() {
        coalescing = false;
        entityResolver = null;
        errorHandler = null;
        ignoreComments = false;
        ignoreElementContentWhitespace = false;
        namespaceAware = false;
    }