Node.java

import java.util.Set;
import java.util.HashSet;

public class Node implements Comparable<Node> {
 private static int cpt = 0;
 private final int id;
 private Linkable data;
 private Node next;

 public Node(Linkable data) {
 this.id = cpt++;
 this.data = data;
 }

 public Linkable getData() {
 return this.data;
 }

 public Node getNext() {
 return this.next;
 }

 public void setNext(Node next) {
 this.next = next;
 }

 /**
 * Goes through each linked Node to count how many nodes there are.
 * @return int for the number of nodes
 */
 public int size() {
 Node current = this;
 int size = 0;

 while (current != null) {
 current = current.getNext();
 size++;
 }

 return size;
 }

 /**
 * Goes to the last Node.
 * @return Node representing the last linked Node, the one that has no next.
 */
 public Node getLast() {
 Node current = this;
 while (current.next != null) {
 current = current.next;
 }
 return current;
 }

 /**
 * Makes a copy of the current Node with its following Nodes
 * @return Node that is independent is its source.
 */
 public Node copy(Node stop) {
 Node copy = new Node(null);
 Node currentOnCopy = copy;
 Node currentOnThis = this;
 int stopId = stop.id;

 while (currentOnThis != null && stopId != currentOnThis.id) {
 currentOnCopy.next = new Node(currentOnThis.getData());
 currentOnCopy = currentOnCopy.next;
 currentOnThis = currentOnThis.next;
 }
 currentOnCopy.next = new Node(currentOnThis.getData());

 return copy.next;
 }

 /**
 * Makes the concatenation of the specified Node and the current one.
 * @param another the Node to append
 * @return Node starting with the parameter Node and followed by the current Node
 */
 public Node concat(Node another) {
 if (another != null) {
 Node toJoin = another.getLast();
 if (toJoin.getData().equals(this.getData())) {
 toJoin.next = this.next;
 } else {
 toJoin.next = this;
 }
 return another;
 } else {
 return this;
 }
 }

 /**
 * Determines which components are crossed by following this linked Node
 * @return Set<String> containing all crossed components
 */
 public Set<String> whichComponentsCrossed() {
 Set<String> crossedComponents = new HashSet<>();
 Set<String> intersection;
 Node current = this;

 while (current.next != null) {
 intersection = Node.intersect(current.getData().getComponents(), current.next.getData().getComponents());
 if (!intersection.isEmpty()) {
 crossedComponents.addAll(intersection);
 }
 current = current.next;
 }

 return crossedComponents;
 }

 /**
 * Determine whether the given Node can replace the specified segment of Nodes
 * without changing the crossed components
 * @param another replacement
 * @param to end Node of the current linked Node
 * @param origin the entire linked Node of the current Node
 * @param all crossed components
 * @return true replaceable
 * @return false not replaceable
 */
 public boolean isReplaceableInComponentsBy(Node another, Node to, Node origin, Set<String> all) {
 Set<String> fusion;

 // Determine the components before this;
 Node saveNextThis = this.next;
 this.next = null;
 fusion = origin.whichComponentsCrossed();
 this.next = saveNextThis;

 // Adding the components of another
 fusion.addAll(another.whichComponentsCrossed());

 // Adding components after
 fusion.addAll(to.whichComponentsCrossed());

 return fusion.containsAll(all);
 }

 /**
 * Replaces a segment of the current linked Node from a start with a specified one.
 * @param stop last Node of the replaced segment
 * @param with linked Nodes replacer
 */
 public void replaceUntil(Node stop, Node with) {
 this.next = (this.equals(with)) ? with.next : with; // Skipping the first node in case of an equality
 Node last = with.getLast();
 last.next = (last.equals(stop)) ? stop.next : stop; // Skipping the last node of the new path in case of equality
 }

 /**
 * Intersection of 2 Sets
 * @param first Set to intersect
 * @param Set to intersect
 * @param the intersection as a Set without modifying the parameters.
 */
 public static Set<String> intersect(Set<String> first, Set<String> second) {
 Set<String> intersection = new HashSet<>(first);
 intersection.retainAll(second);
 return intersection;

 }

 /**
 * Determines which components are crossed by following this linked Node
 * @return Set<String> containing all crossed components
 */
 public Set<String> getCrossedComponents() {
 Set<String> crossedComponents = new HashSet<>();
 Set<String> intersection;
 Node current = this;

 while (current.next != null) {
 intersection = Node.intersect(current.data.getComponents(),current.next.data.getComponents());
 if (intersection.size() >= 1) {
 crossedComponents.addAll(intersection);
 }
 current = current.next;
 }

 return crossedComponents;
 }

 public boolean equals(Node another) {
 return (this.getData().equals(another.getData()));
 }

 @Override
 public boolean equals(Object another) {
 if (!this.getClass().equals(another.getClass())) {
 return false;
 }
 Node anotherNode = (Node)another;
 return (this.equals(anotherNode));
 }

 @Override
 public int hashCode() {
 return this.getData().hashCode();
 }

 @Override
 public int compareTo(Node another) {
 return (this.size() - another.size());
 }

 @Override
 public String toString() { // Print reversed chain
 StringBuilder strb = new StringBuilder();

 if (this.next == null) {
 return ("\n\tGroupe(s) : " + this.getData().getComponents() + "\t : " + this.getData().toString() + "\n\t");

 } else {
 strb.append(this.next);
 // Groupe = Composantes connexes
 strb.append("Groupe(s) : " + this.data.getComponents());
 strb.append("\t : " +this.getData());
 strb.append("\n\t");

 return strb.toString();
 }

 }
}