private boolean applyAfterDirectedEdgeAddition(Update u) {
DirectedEdge e = (DirectedEdge) ((EdgeUpdate) u).getEdge();
DirectedNode src = e.getSrc();
DirectedNode dst = e.getDst();
int srcDegree = src.getOutDegree();
int dstDegree = dst.getOutDegree();
if (richClub.containsKey(srcDegree - 1) && richClub.get(srcDegree - 1).contains(src)) {
if (richClub.containsKey(dstDegree) && richClub.get(dstDegree).contains(dst)) {
this.edgesBetweenRichClub++;
}
removeFromRichclub(src);
addToRichClub(src);
} else if (this.richClub.containsKey(srcDegree - 1)
&& this.nodesSortedByDegree.containsKey(srcDegree - 1)
&& this.nodesSortedByDegree.get(srcDegree - 1).contains(src)) {
// changes for lastNode of Richclub
DirectedNode lastNode = (DirectedNode) this.richClub.get(srcDegree - 1).removeLast();
if (this.richClub.get(lastNode.getOutDegree()).isEmpty()) {
this.richClub.remove(lastNode.getOutDegree());
}
addNodeToRest(lastNode);
// Changes for src node for richclub
this.nodesSortedByDegree.get(srcDegree - 1).remove(src);
if (this.nodesSortedByDegree.get(src.getOutDegree() - 1).isEmpty()) {
this.nodesSortedByDegree.remove(src.getOutDegree() - 1);
}
addToRichClub(src);
// calculate changes for richclub connectivity
for (IElement ie : src.getEdges()) {
DirectedEdge edge = (DirectedEdge) ie;
DirectedNode node = (DirectedNode) edge.getDifferingNode(src);
if (this.richClub.containsKey(node.getOutDegree())
&& this.richClub.get(node.getOutDegree()).contains(node)) {
this.edgesBetweenRichClub++;
}
}
for (IElement ie : lastNode.getEdges()) {
DirectedEdge edge = (DirectedEdge) ie;
DirectedNode node = (DirectedNode) edge.getDifferingNode(lastNode);
if (this.richClub.containsKey(node.getOutDegree())
&& this.richClub.get(node.getOutDegree()).contains(node)) {
this.edgesBetweenRichClub--;
}
}
} else {
this.nodesSortedByDegree.get(src.getOutDegree() - 1).remove(src);
if (this.nodesSortedByDegree.get(src.getOutDegree() - 1).isEmpty()) {
this.nodesSortedByDegree.remove(src.getOutDegree() - 1);
}
addNodeToRest(src);
}
return true;
}
private boolean applyAfterDirectedNodeRemoval(Update u) {
DirectedNode node = (DirectedNode) ((NodeRemoval) u).getNode();
int min = Integer.MAX_VALUE;
int max = 0;
HashMap<Integer, LinkedList<DirectedNode>> order = new HashMap<>();
for (IElement ie : node.getIncomingEdges()) {
DirectedEdge e = (DirectedEdge) ie;
DirectedNode n = e.getSrc();
if (richClub.containsKey(n.getOutDegree() + 1)
&& richClub.get(n.getOutDegree() + 1).contains(n)) {
this.edgesBetweenRichClub--;
min = Math.min(min, n.getOutDegree());
max = Math.max(max, n.getOutDegree());
richClub.get(n.getOutDegree() + 1).remove(n);
if (richClub.get(n.getOutDegree() + 1).isEmpty()) {
richClub.remove(n.getOutDegree() + 1);
}
if (richClub.containsKey(n.getOutDegree())) {
richClub.get(n.getOutDegree()).add(n);
} else {
richClub.put(n.getOutDegree(), new LinkedList<Node>());
richClub.get(n.getOutDegree()).add(n);
}
if (order.containsKey(n.getOutDegree())) {
order.get(n.getOutDegree()).add(n);
} else {
order.put(n.getOutDegree(), new LinkedList<DirectedNode>());
order.get(n.getOutDegree()).add(n);
}
} else if (nodesSortedByDegree.containsKey(n.getOutDegree() + 1)
&& nodesSortedByDegree.get(n.getOutDegree() + 1).contains(n)) {
nodesSortedByDegree.get(n.getOutDegree() + 1).remove(n);
if (nodesSortedByDegree.get(n.getOutDegree() + 1).isEmpty()) {
nodesSortedByDegree.remove(n.getOutDegree() + 1);
}
if (nodesSortedByDegree.containsKey(n.getOutDegree())) {
nodesSortedByDegree.get(n.getOutDegree()).add(n);
} else {
nodesSortedByDegree.put(n.getOutDegree(), new LinkedList<Node>());
nodesSortedByDegree.get(n.getOutDegree()).add(n);
}
} else {
System.out.println("f**k");
}
}
for (int i = min; i <= max; i++) {
boolean f = false;
if (f) {
break;
}
if (!order.containsKey(i)) {
continue;
}
for (DirectedNode n1 : order.get(i)) {
int big = getBiggest();
if (i >= big) {
f = true;
break;
}
// changes for firstNode of Rest
DirectedNode firstNode = (DirectedNode) this.nodesSortedByDegree.get(big).removeFirst();
if (this.nodesSortedByDegree.get(firstNode.getOutDegree()).isEmpty()) {
this.nodesSortedByDegree.remove(firstNode.getOutDegree());
}
addToRichClub(firstNode);
// Changes for src node for richclub
this.richClub.get(i).remove(n1);
if (this.richClub.get(i).isEmpty()) {
this.richClub.remove(i);
}
addNodeToRest(n1);
// calculate changes for richclub connectivity
for (IElement ie : n1.getEdges()) {
DirectedEdge edge = (DirectedEdge) ie;
DirectedNode n2 = (DirectedNode) edge.getDifferingNode(n1);
if (this.richClub.containsKey(n2.getOutDegree())
&& this.richClub.get(n2.getOutDegree()).contains(n2)) {
this.edgesBetweenRichClub--;
}
}
for (IElement ie : firstNode.getEdges()) {
DirectedEdge edge = (DirectedEdge) ie;
DirectedNode n2 = (DirectedNode) edge.getDifferingNode(firstNode);
if (this.richClub.containsKey(n2.getOutDegree())
&& this.richClub.get(n2.getOutDegree()).contains(n2)) {
this.edgesBetweenRichClub++;
}
}
}
}
if (this.richClub.containsKey(node.getOutDegree())
&& this.richClub.get(node.getOutDegree()).contains(node)) {
int degree = ((DirectedNode) node).getOutDegree();
// changes for firstNode of Rest
DirectedNode firstNode =
(DirectedNode) this.nodesSortedByDegree.get(getBiggest()).removeFirst();
if (this.nodesSortedByDegree.get(firstNode.getOutDegree()).isEmpty()) {
this.nodesSortedByDegree.remove(firstNode.getOutDegree());
}
addToRichClub(firstNode);
// Changes for src node for richclub
this.richClub.get(degree).remove(node);
if (this.richClub.get(degree).isEmpty()) {
this.richClub.remove(degree);
}
// calculate changes for richclub connectivity
for (IElement ie : node.getOutgoingEdges()) {
DirectedEdge edge = (DirectedEdge) ie;
DirectedNode n2 = (DirectedNode) edge.getDifferingNode(node);
if (this.richClub.containsKey(n2.getOutDegree())
&& this.richClub.get(n2.getOutDegree()).contains(n2)) {
this.edgesBetweenRichClub--;
}
}
for (IElement ie : firstNode.getEdges()) {
DirectedEdge edge = (DirectedEdge) ie;
DirectedNode n2 = (DirectedNode) edge.getDifferingNode(firstNode);
if (this.richClub.containsKey(n2.getOutDegree())
&& this.richClub.get(n2.getOutDegree()).contains(n2)) {
this.edgesBetweenRichClub++;
}
}
} else {
int degree = ((DirectedNode) node).getOutDegree();
this.nodesSortedByDegree.get(degree).remove(node);
if (this.nodesSortedByDegree.get(degree).isEmpty()) {
this.nodesSortedByDegree.remove(degree);
}
}
return true;
}