Node ensureMaster() {
    Node n = getMasterNode();
    if (n != null) {
      n.update();
      if (n._isMaster) return n;
    }

    if (_lastPrimarySignal != null) {
      n = findNode(_lastPrimarySignal);
      n.update();
      if (n._isMaster) return n;
    }

    updateAll();
    return getMasterNode();
  }
 private void checkNodeValidity(@NotNull DefaultMutableTreeNode node) {
   Enumeration enumeration = node.children();
   while (enumeration.hasMoreElements()) {
     checkNodeValidity((DefaultMutableTreeNode) enumeration.nextElement());
   }
   if (node instanceof Node && node != getModelRoot()) ((Node) node).update(this);
 }
示例#3
0
  // rotates edge (x, x.parent)
  //        g            g
  //       /            /
  //      p            x
  //     / \    ->    / \
  //    x  p.r      x.l  p
  //   / \              / \
  // x.l x.r          x.r p.r
  static void rotate(Node x) {
    Node p = x.parent;
    Node g = p.parent;
    boolean isRootP = p.isRoot();
    boolean leftChildX = (x == p.left);

    // create 3 edges: (x.r(l),p), (p,x), (x,g)
    connect(leftChildX ? x.right : x.left, p, leftChildX);
    connect(p, x, !leftChildX);
    connect(x, g, !isRootP ? p == g.left : null);
    p.update();
  }
示例#4
0
 // brings x to the root, balancing tree
 //
 // zig-zig case
 //        g                                  x
 //       / \               p                / \
 //      p  g.r rot(p)    /   \     rot(x) x.l  p
 //     / \      -->    x       g    -->       / \
 //    x  p.r          / \     / \           x.r  g
 //   / \            x.l x.r p.r g.r             / \
 // x.l x.r                                    p.r g.r
 //
 // zig-zag case
 //      g               g
 //     / \             / \               x
 //    p  g.r rot(x)   x  g.r rot(x)    /   \
 //   / \      -->    / \      -->    p       g
 // p.l  x           p  x.r          / \     / \
 //     / \         / \            p.l x.l x.r g.r
 //   x.l x.r     p.l x.l
 static void splay(Node x) {
   while (!x.isRoot()) {
     Node p = x.parent;
     Node g = p.parent;
     if (!p.isRoot()) g.push();
     p.push();
     x.push();
     if (!p.isRoot()) rotate((x == p.left) == (p == g.left) ? p /*zig-zig*/ : x /*zig-zag*/);
     rotate(x);
   }
   x.push();
   x.update();
 }
  synchronized void updateAll() {
    HashSet<Node> seenNodes = new HashSet<Node>();
    for (int i = 0; i < _all.size(); i++) {
      Node n = _all.get(i);
      n.update(seenNodes);
    }

    if (!seenNodes.isEmpty()) {
      // not empty, means that at least 1 server gave node list
      // remove unused hosts
      Iterator<Node> it = _all.iterator();
      while (it.hasNext()) {
        if (!seenNodes.contains(it.next())) it.remove();
      }
    }
  }