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);
}
// 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();
}
// 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();
}
}
}
