td7 1 ok

2020-2021/src/TD6/facebookGhost/Event.java

@@ -0,0 +1,5 @@
+package TD6.facebookGhost;
+
+public interface Event {
+
+}

2020-2021/src/TD6/facebookGhost/FacebookGhostNetwork.java

@@ -0,0 +1,137 @@
+package TD6.facebookGhost;
+
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Observable;
+
+/**
+ *
+ * Inspired by
+ * //https://github.com/roundrop/facebook4j/blob/master/facebook4j-core/src/main/java/facebook4j/api/FriendMethods.java
+ * pour imaginer une esquisse de reseau tres tres simplifie
+ * 
+ * @author blay
+ *
+ */
+public class FacebookGhostNetwork {
+
+	public static final String DEFAULT_LOCATION = "unspecified";
+	HashMap<String, User> users = new HashMap<>();
+
+	//To be observable
+	private PropertyChangeSupport observables;
+
+	public void addPropertyChangeListener(PropertyChangeListener pcl) {
+		observables.addPropertyChangeListener(pcl);
+	}
+
+	public void removePropertyChangeListener(PropertyChangeListener pcl) {
+		observables.removePropertyChangeListener(pcl);
+	}
+
+	//Constructor
+	public FacebookGhostNetwork() {
+		observables = new PropertyChangeSupport(this);
+	}
+
+	
+	public User addUser(String nom, String profile) {
+		return addUser(nom, profile, DEFAULT_LOCATION);
+	}
+
+	public User addUser(String nom, String profile, String location) {
+		User user = new UserImpl(nom, profile, location);
+		users.put(nom, user);
+		Event e = new UserEvent(user);
+		observables.firePropertyChange("addUser", null, e);
+		return user;
+	}
+
+	/**
+	 * Returns a user's friends.
+	 * 
+	 * @param userId the ID of a user
+	 * @return users
+	 * @see <a href=
+	 *      "https://developers.facebook.com/docs/reference/api/user/#friends">User#friends
+	 *      - Facebook Developers</a>
+	 */
+	ArrayList<User> getFriends(String userId) {
+		return getUser(userId).getFriends();
+	}
+
+	/**
+	 * Returns a user's family members.
+	 * 
+	 * @param userId the ID of a user
+	 * @return users
+	 * @see <a href=
+	 *      "https://developers.facebook.com/docs/reference/api/user/#friends">User#friends
+	 *      - Facebook Developers</a>
+	 */
+	ArrayList<User> getFamily(String userId) {
+		return getUser(userId).getFamily();
+	}
+
+	/**
+	 * Returns a given user, specified by ID.
+	 * 
+	 * @param userId the ID of the user
+	 * @return user remove but not the use of dedicated exception !! @throws
+	 *         FacebookException when Facebook service or network is unavailable
+	 * @see <a href="https://developers.facebook.com/docs/reference/api/user/">User
+	 *      - Facebook Developers</a>
+	 */
+	public User getUser(String userId) {
+		return users.get(userId);
+	}
+
+	/**
+	 * Create a relation between 2 given members of a same family
+	 * 
+	 * @param id1 the ID of the user
+	 * @param id2 the ID of the user
+	 */
+	public void addFamilyRelation(String id1, String id2) {
+		User u1 = users.get(id1);
+		User u2 = users.get(id2);
+		addFamilyRelation(u1, u2);
+
+	}
+
+	public void addFamilyRelation(User u1, User u2) {
+		u1.addFamily(u2);
+		u2.addFamily(u1);
+		Event e = new RelationEvent("family", u1, u2);
+		observables.firePropertyChange("addFamilyRelation", null, e);
+
+	}
+
+	/**
+	 * Create a relation between 2 given friends
+	 * 
+	 * @param id1 the ID of the user
+	 * @param id2 the ID of the user
+	 */
+	public void addFriendRelation(String id1, String id2) {
+		User u1 = users.get(id1);
+		User u2 = users.get(id2);
+		addFriendRelation(u1, u2);
+	}
+
+	public void addFriendRelation(User u1, User u2) {
+		u1.addFriend(u2);
+		u2.addFriend(u1);
+		Event e = new RelationEvent("Friend", u1, u2);
+		observables.firePropertyChange("addFriendRelation", null, e);
+
+	}
+
+	@Override
+	public String toString() {
+		return "FacebookGhostNetwork [ " + users + "]";
+	}
+
+}

2020-2021/src/TD6/facebookGhost/IdNameEntity.java

@@ -0,0 +1,6 @@
+package TD6.facebookGhost;
+
+public interface IdNameEntity {
+	String	getId();
+	 String	getName();
+}

2020-2021/src/TD6/facebookGhost/IdNameEntityImpl.java

@@ -0,0 +1,25 @@
+package TD6.facebookGhost;
+
+public class IdNameEntityImpl implements IdNameEntity {
+
+	private String id;
+	private String name;
+	
+	@Override
+	public String getId() {
+		return id;
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	public IdNameEntityImpl(String id, String name) {
+		super();
+		this.id = id;
+		this.name = name;
+	}
+
+
+}

2020-2021/src/TD6/facebookGhost/RelationEvent.java

@@ -0,0 +1,32 @@
+package TD6.facebookGhost;
+
+public class RelationEvent implements Event {
+	public String getNature() {
+		return nature;
+	}
+
+	public User getU1() {
+		return u1;
+	}
+
+	public User getU2() {
+		return u2;
+	}
+
+	String nature;
+	User u1;
+	User u2;
+	
+	public RelationEvent(String nature, User u1, User u2) {
+		this.nature = nature;
+		this.u1 = u1;
+		this.u2=u2;
+	}
+
+	@Override
+	public String toString() {
+		return "RelationEvent [nature=" + nature + ", u1=" + u1 + ", u2=" + u2
+				+ "]";
+	}
+
+}

2020-2021/src/TD6/facebookGhost/User.java

@@ -0,0 +1,104 @@
+package TD6.facebookGhost;
+
+/*import java.net.URL;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;*/
+
+import java.util.ArrayList;
+
+/**
+ * Emprunt<EFBFBD> <EFBFBD> https://github.com/roundrop/facebook4j
+ * @author Ryuji Yamashita - roundrop at gmail.com
+ */
+public interface User {
+
+	String myProfil();
+	String getId();
+	String getName();
+	/* String getFirstName();
+    String getMiddleName();
+    String getLastName();
+    String getGender();
+    Locale getLocale();
+    List<IdNameEntity> getLanguages();
+    URL getLink();
+    String getUsername();
+    String getThirdPartyId();
+    Boolean isInstalled();
+    Double getTimezone();
+    Date getUpdatedTime();
+    Boolean isVerified();
+    String getBio();
+    String getBirthday();
+//    Cover getCover();
+    List<User.Education> getEducation();
+    String getEmail();
+	 */
+	IdNameEntity getHometown();
+	/*
+    List<String> getInterestedIn();
+    IdNameEntity getLocation();
+    String getPolitical();
+    List<IdNameEntity> getFavoriteAthletes();
+    List<IdNameEntity> getFavoriteTeams();
+//    Picture getPicture();
+    String getQuotes();
+    String getRelationshipStatus();
+    String getReligion();
+    IdNameEntity getSignificantOther();
+    User.VideoUploadLimits getVideoUploadLimits();
+    URL getWebsite();
+    List<User.Work> getWork();
+;
+
+    interface Education {
+        IdNameEntity getYear();
+        String getType();
+        IdNameEntity getSchool();
+        IdNameEntity getDegree();
+        List<IdNameEntity> getConcentration();
+        List<User.EducationClass> getClasses();
+        List<IdNameEntity> getWith();
+    }
+
+    interface EducationClass {
+        List<IdNameEntity> getWith();
+        String getDescription();
+    }
+
+    interface VideoUploadLimits {
+        long getLength();
+        long getSize();
+    }
+
+    interface Work {
+        IdNameEntity getEmployer();
+        IdNameEntity getLocation();
+        IdNameEntity getPosition();
+        String getStartDate();
+        String getEndDate();
+
+    }*/
+
+	User.AgeRange getAgeRange();
+	interface AgeRange {
+		// one value could be null (13-17 / 18-20 / 21 - null)
+		Integer getMin();
+		Integer getMax();
+		int getAge();
+	}
+	ArrayList<User> getFriends();
+	void addFriend(User friend);
+	void addFamily(User familyMember);
+	ArrayList <User>getFamily();
+
+	void setLocation(String name);
+	//String BIRTHDAY_DATE_FORMAT = "MM/dd/yyyy";
+
+
+
+
+}

2020-2021/src/TD6/facebookGhost/UserEvent.java

@@ -0,0 +1,11 @@
+package TD6.facebookGhost;
+
+public class UserEvent implements Event {
+
+	User user;
+	
+	public UserEvent(User user) {
+		this.user = user;
+	}
+
+}

2020-2021/src/TD6/facebookGhost/UserImpl.java

@@ -0,0 +1,105 @@
+package TD6.facebookGhost;
+
+import java.util.ArrayList;
+
+
+public class UserImpl implements User {
+
+	
+	private String id;
+	private String myProfile;
+	private User.AgeRange range;
+	private IdNameEntity homeTown;
+	
+	
+	 class AgeRangeImpl implements User.AgeRange{
+
+		int age = 20;
+		public Integer getMin() {
+			return 0;
+		}
+
+		public Integer getMax() {
+			return 120;
+		}
+
+		public int getAge() {
+			return age;
+		}
+		
+	}
+		
+	 
+	 public UserImpl(String id, String profile, String phomeTown) {
+			this.id = id;
+			myProfile = profile;
+			range = new AgeRangeImpl();
+			homeTown = new IdNameEntityImpl(phomeTown,phomeTown);
+		}
+		
+
+	public UserImpl(String id, String profile) {
+		this.id = id;
+		myProfile = profile;
+		range = new AgeRangeImpl();
+	}
+
+	public String myProfil() {
+		return myProfile;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public String getName() {
+		return id;
+	}
+
+	public AgeRange getAgeRange() {
+		return range;
+	}
+
+
+
+	private ArrayList friends = new ArrayList ();
+	
+	public void addFriend(User friend) {
+		friends.add(friend);
+	}
+
+	public ArrayList getFriends() {
+		return friends;
+	}
+	
+	private ArrayList family = new ArrayList ();
+	
+	public void addFamily(User familyMember) {
+		family.add(familyMember);
+	}
+	
+	public ArrayList getFamily(){
+		return family;
+	}
+
+	@Override
+	public String toString() {
+		return "UserImpl [id=" + id + ", myProfile=" + myProfile + ", range="
+				+ range + 
+				//",friends=" + friends + ", family=" + family + 
+				"]";
+	}
+
+	@Override
+	public IdNameEntity getHometown() {
+		return homeTown;
+	}
+
+
+	@Override
+	public void setLocation(String name) {
+		homeTown = new IdNameEntityImpl(name,name) ;
+	}
+	
+	
+}

2020-2021/src/TD6/grapheSimple/Chemin.java

@@ -0,0 +1,194 @@
+package TD6.grapheSimple;
+
+import TD6.grapheX.Arc;
+import TD6.grapheX.Identifiable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * La classe Chemin définit un chemin comme un ensemble d'arcs et maintient pour
+ * chaque chemin la somme des valeurs des arcs
+ * 
+ * @author blay
+ * @param <S>
+ *
+ */
+public class Chemin<S extends Identifiable> implements Comparable<Chemin<S>> {
+
+	// On pourrait éviter cet attribut en calculant la distance à la demande.
+	int distance = 0;
+
+	List<Arc<S>> paths = new ArrayList<>();
+
+	public Chemin() {
+		paths = new ArrayList<>();
+	}
+
+	public Chemin(List<Arc<S>> arcs) {
+		paths = arcs;
+	}
+
+	/**
+	 * @return le Sommet terminant le chemin si le chemin est vide il vaut null
+	 */
+	public S arrivee() {
+		if (paths.isEmpty())
+			return null;
+		Arc<S> arc = paths.get(paths.size() - 1);
+		return arc.destination();
+	}
+
+	/**
+	 * @return la somme des valeurs des arcs
+	 */
+	public int distance() {
+		return distance;
+	}
+
+	/**
+	 * @return la liste des arcs qui composent le chemin Attention dangereux une
+	 *         copie serait préférable
+	 */
+	public List<Arc<S>> getArcs() {
+		return paths;
+	}
+
+	/**
+	 * Ajoute un arc <EFBFBD> la fin du chemin
+	 * 
+	 * @TODO : verifier que le dernier noeud est bien le premier noeud de l'arc
+	 *       ajoute
+	 */
+	public boolean add(Arc<S> e) {
+		distance += e.valeur();
+		return paths.add(e);
+	}
+
+	public void add(int x, Arc<S> e) {
+		distance += e.valeur();
+		paths.add(x, e);
+	}
+
+	public boolean addAll(Collection<Arc<S>> c) {
+		for (Arc<S> a : c)
+			distance += a.valeur();
+		return paths.addAll(c);
+	}
+
+	public void clear() {
+		distance = 0;
+		paths.clear();
+
+	}
+
+	/**
+	 * verifie l'appartenance d'un arc au chemin
+	 * 
+	 * @param arc
+	 * @return vrai si l'arc appartient au chemin
+	 */
+	public boolean contains(Arc<S> arc) {
+		return paths.contains(arc);
+	}
+
+	public boolean isEmpty() {
+		return paths.isEmpty();
+	}
+
+	public boolean remove(Arc<S> o) {
+		return paths.remove(o);
+	}
+
+	public boolean removeAll(Collection<Arc<S>> c) {
+		return paths.removeAll(c);
+	}
+
+	public int size() {
+		return paths.size();
+	}
+
+	@Override
+	public String toString() {
+		return "Chemin [dist.=" + distance + ", paths=" + paths + "]";
+	}
+
+	/**
+	 * d<EFBFBD>termine si le sommet appartient au chemin
+	 * 
+	 * @param sommet
+	 * @return vrai si le sommet appartient au chemin
+	 */
+	public boolean atteint(S sommet) {
+		for (Arc<S> a : paths)
+			if (a.destination().equals(sommet))
+				return true;
+		return false;
+	}
+
+	/**
+	 * @param depart
+	 * @param arrivee
+	 * @return le sous-chemin reliant depart et arrivee si les deux noeuds
+	 *         appartiennent au chemin.
+	 * 
+	 */
+	public Chemin<S> extraireChemin(S depart, S arrivee) {
+		boolean debutee = false;
+		Chemin<S> c = new Chemin<>();
+		for (Arc<S> a : paths) {
+			if (debutee) {
+				c.add(a);
+			}
+			if (a.origine().equals(depart)) {
+				c.add(a);
+				debutee = true;
+			}
+			if (debutee && a.destination().equals(arrivee))
+				return c;
+		}
+		return c;
+
+	}
+
+	public int compareTo(Chemin<S> c) {
+		if (this.distance() < c.distance())
+			return -1;
+		else if (this.distance() == c.distance())
+			return 0;
+		else
+			return 1;
+
+	}
+
+	public boolean equals(Object o) {
+		if (!(o instanceof Chemin))
+			return false;
+		
+		Chemin<S> o2 = (Chemin<S>) o;
+		Chemin<S> c = o2;
+		if ((distance == c.distance) && (c.paths.size() == this.paths.size())) {
+			for (Arc<S> a : c.paths) {
+				if (!paths.contains(a)) {
+					return false;
+				}
+			}
+			return true;
+		} 
+		else
+			return false;
+
+	}
+
+	public List<S> sommets() {
+		List<S> sommets = new ArrayList<>();
+		if (! paths.isEmpty()) {
+			for (Arc<S> arc : paths)
+				sommets.add(arc.origine());
+			sommets.add(paths.get(paths.size() - 1).destination());
+		}
+		return sommets;
+	}
+
+}

2020-2021/src/TD6/grapheSimple/GrapheSimple.java

@@ -0,0 +1,267 @@
+package TD6.grapheSimple;
+
+import TD6.grapheX.Arc;
+import TD6.grapheX.Graphe;
+import TD6.grapheX.Sommet;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Cette classe a ete necessaire pour gérer les graphes ayant plusieurs arétes entre deux sommets données
+ * et ayant des arcs dans les deux sens entre deux sommets.
+ * Ces fonctionnalités n'étaient pas prises en charge par les classes initiales.
+ * Elle permet egalement de simplifier la comprehension des codes données.
+ * @author blay
+ *
+ */
+public class GrapheSimple<T extends Sommet> extends Graphe<T> {
+    HashMap<String,T> mesSommets = new HashMap<>();
+
+    HashMap<T,HashMap<T,ArrayList<Arc<T>>>> aretes;
+
+
+    public  GrapheSimple() {
+        aretes = new HashMap<>();
+    }
+
+
+    public T getSommet(String ident){
+        return mesSommets.get(ident);
+    }
+
+    @Override
+    public int taille() {
+        return mesSommets.size();
+    }
+
+
+    @Override
+
+    public Graphe<T> copie() {
+        //@TODO
+        return null;
+    }
+
+    //n'ajoute le sommet que s'il n'est pas deja dans le graphe.
+    @Override
+    public void ajouterSommet(T s) {
+        if (existeSommet(s))
+            return;
+        mesSommets.put(s.identifiant(), s);
+        aretes.put(s,new HashMap<T,ArrayList<Arc<T>>>());
+    }
+
+    @Override
+    public boolean existeArc(Sommet s, Sommet t) {
+        return aretes.get(s).containsKey(t);
+    }
+
+
+    //A revoir avec la nouvelle version
+    //@todo
+    private boolean existeSommet(T s) {
+        return aretes.containsKey(s);
+    }
+
+
+    public List<Arc<T>> arcs(T s, T t) {
+        return aretes.get(s).get(t);
+    }
+
+    @Override
+    public void ajouterArc(T s, T t) {
+        this.ajouterArc(s,t,0);
+    }
+
+
+    @Override
+    public void ajouterArc(Arc<T> arc) {
+        HashMap<T, ArrayList<Arc<T>>> s = aretes.get(arc.origine());
+        if (s == null){
+            ajouterSommet(arc.origine());
+            s=aretes.get(arc.origine());
+        }
+        if (aretes.get(arc.destination()) == null)
+            ajouterSommet(arc.destination());
+        if  (s.get(arc.destination()) == null)
+            s.put(arc.destination(), new ArrayList<>());
+        s.get(arc.destination()).add(arc);
+
+    }
+    @Override
+    public void ajouterArc(T s, T t, int val) {
+        Arc<T> a = new Arc<>(s,t,val);
+        this.ajouterArc(a);
+    }
+
+    //Remarque : gestion horrible des exceptions mais on s'adapte à cause de l'héritage qui nous interdit de lever une exception.
+    @Override
+    public int valeurArc(T s, T t)  {
+        if (!existeArc(s,t)) throw new Error("Arc inexistant");
+        return aretes.get(s).get(t).get(0).valeur();
+    }
+
+    //RETIRE TOUS LES ARCS VERS T
+    @Override
+    public void enleverArc(Sommet s, Sommet t) {
+        if (!existeArc(s,t)) return ;
+        aretes.get(s).remove(t);
+    }
+
+    @Override
+    public Collection<T> sommets() {
+        return mesSommets.values();
+    }
+
+    @Override
+    public Collection<Arc<T>> voisins(Sommet s) {
+        ArrayList<Arc<T>> voisins = new ArrayList<>();
+        HashMap<T, ArrayList<Arc<T>>> arcs = aretes.get(s);
+        if ( arcs != null )
+            for (ArrayList<Arc<T>> av : arcs.values())
+                voisins.addAll(av);
+        return voisins ;
+    }
+
+    @Override
+    public String toString() {
+        return "Sommets=" + mesSommets + ";\n arcs="
+                + toStringArretes(aretes) + "]";
+    }
+
+    private String toStringArretes(
+            HashMap<T, HashMap<T, ArrayList<Arc<T>>>> aretes2) {
+        StringBuilder bld = new StringBuilder();
+        for ( HashMap<T, ArrayList<Arc<T>>> x : aretes2.values()){
+            for ( ArrayList<Arc<T>> edges : x.values())
+                for (Arc<T> a : edges)
+                    bld.append( "\t").append(a).append("\n" );
+        }
+        return bld.toString();
+    }
+
+
+    /**
+	 * @param origine
+	 * @return une liste de chemins
+	 * Cette m<EFBFBD>thode renvoie les chemins les plus longs possibles <EFBFBD> partir du point d'orgine
+	 */
+	public List<Chemin<T>> chemins(T origine){
+		HashMap<T,ArrayList<Arc<T>>> dejaVu = new HashMap<>();
+		return chemins(origine,dejaVu);
+	}
+	
+	/**
+	 * @param origine
+	 * @param destination
+	 * @return une liste de chemins entre deux Ts
+	 * Cette m<EFBFBD>thode renvoie tous les chemins entre deux Sommets donnes
+	 */
+	//Pbme avec la comparaison des chemins... qui considere comme <EFBFBD>gal deux objets diff<EFBFBD>rents... cela doit venir de l'h<EFBFBD>ritage...
+
+	public List<Chemin<T>> chemins(T origine, T destination){
+		List<Chemin<T>> chemins = chemins(origine);
+		List<Chemin<T>> cheminsEntreDeuxSommets = new ArrayList<> ();
+		for(Chemin<T> c : chemins) {
+			if (c.atteint(destination)){
+				Chemin<T> raccourcis = c.extraireChemin(origine, destination);
+				if (! cheminsEntreDeuxSommets.contains(raccourcis)) {
+					cheminsEntreDeuxSommets.add(raccourcis);
+				}
+			}
+		}
+		return cheminsEntreDeuxSommets;
+	}
+	
+
+	private List<Chemin<T>> chemins(T origine, HashMap<T,ArrayList<Arc<T>>> dejaVu){
+
+		List<Chemin<T>> chemins = new ArrayList<>();
+
+		if  (dejaVu.containsKey(origine)){
+			chemins.add(new Chemin<>(dejaVu.get(origine)));
+			return chemins;
+		}
+
+		
+		dejaVu.put(origine, new ArrayList<Arc<T>>());
+
+
+		Collection<Arc<T>> voisins = voisins(origine);	
+		HashMap<T,ArrayList<Arc<T>>> dejavVuLocal ;
+
+		for (Arc<T> a : voisins) {
+			T destination = a.destination();
+			dejavVuLocal= new HashMap<>(dejaVu);
+
+			if (nouvelleDestinationOuNouvelArcSansRetour(origine,dejavVuLocal,destination,a)) { 
+				dejavVuLocal.get(origine).add(a);
+				List<Chemin<T>> cheminsLocaux = chemins(destination,dejavVuLocal);
+				if (cheminsLocaux.isEmpty()) {
+					Chemin<T> chemin = new Chemin<>();
+					chemin.add(a);
+					chemins.add(chemin);
+					}
+				else {
+					for (Chemin<T> c : cheminsLocaux) {
+						c.add(0,a);
+						chemins.add(c);
+					}
+				}
+			}
+		}
+		return chemins;
+	}
+	
+	//todo : tenir compte de Origine
+		private boolean nouvelleDestinationOuNouvelArcSansRetour(
+			T origine, HashMap<T, ArrayList<Arc<T>>> dejaVu, T destination,
+			Arc<T> a) {
+
+			if (! dejaVu.containsKey(destination) )
+				return true;
+
+			return ( (! dejaVu.get(destination).contains(a)) && (! dejaVu.containsKey(a.destination()) ) );
+		}
+		
+		
+		public Chemin<T> cheminLePlusCourt(T origine, T destination){
+			List<Chemin<T>> chemins = this.chemins(origine, destination);
+			Chemin<T> cheminLePlusCourt = null;
+			int distanceLaPlusCourte = Integer.MAX_VALUE;
+			for(Chemin<T> c : chemins) {
+				if (distanceLaPlusCourte > c.distance()) {
+					distanceLaPlusCourte = c.distance();
+					cheminLePlusCourt = c;
+				}
+			}
+			return cheminLePlusCourt;
+		}
+
+		/**
+		 * @param origine
+		 * @param rang
+		 * @return l'ensemble des voisins de {@code origine} au rang {@code rang}, i.e. qu'il y a {@code rang} arcs entre eux.
+		 */
+		public Set<T> voisinsAuRang(T origine, int rang){
+			List<Chemin<T>> chemins = chemins(origine);
+			Set<T> tsVoisinsDejaVu = new TreeSet<>();
+			Set<T> tsDeBonRang = new TreeSet<>();
+			for (Chemin<T> c : chemins) {
+				List<T> sommets = c.sommets();
+				int i = 0;
+				for (i = 0; (i <sommets.size() && i < rang); i++)
+					tsVoisinsDejaVu.add(sommets.get(i));
+				if ( (i == rang) && (i < sommets.size()) )
+					tsDeBonRang.add(sommets.get(i));
+				}
+			tsDeBonRang.removeAll(tsVoisinsDejaVu);
+			return tsDeBonRang;
+		}
+
+}

2020-2021/src/TD6/grapheX/Arc.java

@@ -0,0 +1,83 @@
+package TD6.grapheX;
+
+/**
+ * Classe d'arcs
+ * 
+ * @author FMorain (morain@lix.polytechnique.fr)
+ * @author PChassignet (chassign@lix.polytechnique.fr)
+ * @author JCervelle (julien.cervelle@univ-mlv.fr)
+ * @version 2007.03.21
+ */
+
+// L'arc o -> d avec valeur val
+public class Arc<S extends Identifiable> implements Comparable<Arc<S>> {
+  private S o, d;
+
+  private int val;
+
+  public Arc(S o0, S d0, int val0) {
+    this.o = o0;
+    this.d = d0;
+    this.val = val0;
+  }
+
+  public Arc(S o0, S d0) {
+    this.o = o0;
+    this.d = d0;
+    this.val = 0;
+  }
+
+  public Arc(Arc<S> a) {
+    this.o = a.o;
+    this.d = a.d;
+    this.val = a.val;
+  }
+
+  public S destination() {
+    return d;
+  }
+
+  public S origine() {
+    return o;
+  }
+
+  public int valeur() {
+    return val;
+  }
+
+  public void modifierValeur(int vv) {
+    this.val = vv;
+  }
+
+  @Override
+public String toString() {
+    return "(" + val + ":" + this.o + ", " + this.d + ")";
+  }
+
+  @Override
+public int hashCode() {
+    int codeOri = (o == null ? 0 : o.hashCode());
+    int codeDst = (d == null ? 0 : d.hashCode());
+    return codeDst ^ (codeOri * 31);
+  }
+
+  @Override
+public boolean equals(Object aa) {
+    if (!(aa instanceof Arc))
+      return false;
+    Arc<?> arc = (Arc<?>) aa;
+    boolean equalsO = o == null && arc.o == null || o != null
+        && o.equals(arc.o);
+    boolean equalsD = d == null && arc.d == null || d != null
+        && d.equals(arc.d);
+    return equalsO && equalsD && (val == arc.val);
+  }
+
+public int compareTo(Arc<S> a) {
+    int comp = Identifiable.compare(this.o, a.o);
+    if (comp == 0)
+      comp = Identifiable.compare(d, a.d);
+    return comp;
+  }
+
+}

2020-2021/src/TD6/grapheX/Graphe.java

@@ -0,0 +1,871 @@
+package TD6.grapheX;
+
+import java.util.*;
+
+/**
+   Classe abstraite de graphes
+
+
+   @author FMorain (morain@lix.polytechnique.fr)
+   @version 2008.03.01
+   @author MBF revisée pour la rendre générique
+ */
+
+public abstract class Graphe<T extends Sommet> extends GrapheGenerique<T>{
+
+  @Override
+public abstract int taille();
+ public abstract Graphe<T> copie();
+
+  @Override
+public abstract void ajouterSommet(T s);
+  @Override
+public abstract boolean existeArc(T s, T t);
+  @Override
+public abstract void ajouterArc(T s, T t, int val);
+  public abstract void ajouterArc(Arc<T> arc);
+  @Override
+public abstract int valeurArc(T s, T t);
+  @Override
+public abstract void enleverArc(T s, T t);
+
+  @Override
+public abstract Collection<T> sommets();
+  @Override
+public abstract Collection<Arc<T>> voisins(T s);
+  
+  public boolean oriente;
+  
+  public static String version(){
+  	return "grapheX -- version 1.3d, 2008/02/27";
+  }
+
+  public void ajouterArc(T s, T t){
+    ajouterArc(s, t, 0);
+  }
+  
+  public boolean existeArc(Arc<T> alpha){
+    return existeArc(alpha.origine(), alpha.destination());
+  }
+  
+
+
+public String toString(){
+    String str = "";
+
+    for(T s : sommets()){
+      str += s + ":";
+      for(T t : sommets()){
+        if(existeArc(s, t))
+          str += " " + valeurArc(s, t);
+        else
+          str += " -";
+      }
+      str += "\n";
+    }
+    return str;
+  }
+
+ /* public void faireComplet(){
+    int n = taille();
+    for(int i = 0; i < n; i++)
+      ajouterSommet(new Sommet(i+""));
+    for(Sommet s : sommets())
+      for(Sommet t : sommets())
+        if(!s.equals(t))
+          ajouterArc(s, t, 1);
+  }
+
+  public static void afficherParcours(HashMap<Sommet,Integer> L){
+	System.err.println("PARCOURS");
+    for(Sommet s : L.keySet())
+      System.err.print(" ["+s+", "+L.get(s)+"]");
+    System.err.println();
+  }
+
+  public static Graphe RoyWarshall(Graphe G){
+    Graphe F = G.copie();
+
+    for(Sommet s : G.sommets())
+      F.ajouterArc(s, s, 1);
+    System.err.println("FT_ini = \n"+F);
+    for(Sommet r : G.sommets()){
+      for(Sommet s : G.sommets())
+        for(Sommet t : G.sommets())
+          if(!F.existeArc(s, t)
+              && (F.existeArc(s, r) && F.existeArc(r, t)))
+            F.ajouterArc(s, t, 1);
+      System.err.println("\nA_"+r);
+      System.err.println(F);
+    }
+    return F;
+  }*/
+
+  //////////////////// Dijkstra ////////////////////
+
+  public HashMap<T,Integer> Dijkstra(T s){
+    int INFINITY = 1000000;
+    HashMap<T,Integer> L = new HashMap<T,Integer>();
+
+    // 1. initialisation
+    for(T t : sommets())
+      if(! t.equals(s))
+        if(existeArc(s, t))
+          L.put(t, valeurArc(s, t));
+        else
+          L.put(t, INFINITY);
+    // 2. 
+    HashSet<T> U = new HashSet<>(sommets()); // copie
+    L.put(s, 0);
+    U.remove(s);
+    // 3.
+    while(! U.isEmpty()){
+      //afficherParcours(L);
+      // 4.
+      T v = null;
+      int Lv = INFINITY;
+      for(T t : U)
+        if(L.get(t) < Lv){
+          v = t;
+          Lv = L.get(t);
+        }
+      System.err.println("-->v="+v);
+      // 5.
+      U.remove(v);
+      // 6.
+      //	    for(Sommet t : U)
+      //		if(existeArc(v, t)){
+      for(Arc<T> a : voisins(v)){
+        T t = a.destination();
+        int tmp = Lv + a.valeur();
+        if(tmp < L.get(t))
+          L.put(t, tmp);
+      }
+    }
+    return L;
+  }
+/*
+  TreeSet<SommetValue> Dijkstra2Init(HashMap<T,Integer> L, T s){
+    int INFINITY = 1000000;
+    TreeSet<SommetValue> fp = 
+      new TreeSet<SommetValue>(
+          new Comparator<SommetValue>() {
+            public int compare(SommetValue s1, SommetValue s2) {
+              if(s1.valeur < s2.valeur)
+                return -1;
+              else if(s1.valeur > s2.valeur)
+                return 1;
+              if(s1.s.equals(s2.s))
+                return 0;
+              return -1;
+            }
+          }
+      );
+    for(Sommet u : sommets()){
+      if(u.equals(s))
+        L.put(u, 0);
+      else if(existeArc(s, u)){
+        int val = valeurArc(s, u);
+        fp.add(new SommetValue(u, val));
+        L.put(u, val);
+      }
+      else{
+        fp.add(new SommetValue(u, INFINITY));
+        L.put(u, INFINITY);
+      }
+    }
+    return fp;
+  }
+
+  public HashMap<T,Integer> Dijkstra2(T s){
+    HashMap<T,Integer> L = new HashMap<T,Integer>();
+
+    // 1. initialisation
+    TreeSet<SommetValue> U = Dijkstra2Init(L, s);
+    // 3.
+    while(! U.isEmpty()){
+      //afficherParcours(L);
+      // 4.
+      SommetValue v = U.first();
+      U.remove(v);
+      int Lv = v.valeur;
+      //System.err.println("v="+v.s+" Lv="+Lv);
+      // 5.
+      // 6.
+      for(Arc<T> a : voisins(v.s)){
+        Sommet t = a.destination();
+        int tmp = Lv + a.valeur();
+        if(tmp < L.get(t)){
+        //  System.err.println("-"+t+" "+L.get(t));
+          U.remove(new SommetValue(t, L.get(t)));
+         // System.err.println("+"+t+" "+tmp);
+          U.add(new SommetValue(t, tmp));
+          L.put(t, tmp);
+        }
+      }
+    }
+    return L;
+  }
+
+  public void Prim(){
+    HashSet<Sommet> HS = new HashSet<Sommet>();
+    for(Sommet u : sommets()){
+      if(! HS.contains(u)){
+        //System.err.println("Je pars de "+u);
+        HS.add(u);
+        TreeSet<Arc<Sommet>> fp =
+          new TreeSet<Arc<Sommet>>(
+              new Comparator<Arc<Sommet>>(){
+				public int compare(Arc<Sommet> a1, Arc<Sommet> a2){
+                  if(a1.valeur() < a2.valeur())
+                    return -1;
+                  else if(a1.valeur() > a2.valeur())
+                    return 1;
+                  else if(a1.equals(a2))
+                    return 0;
+                  else if(! a1.origine().equals(a2.origine()))
+                    return a1.origine().compareTo(a2.origine());
+                  else if(! a1.destination().equals(a2.destination()))
+                    return a1.destination().compareTo(a2.destination());
+                  else
+                    return 0;
+                }
+              }
+          );
+        for(Arc<Sommet> a : voisins(u)){
+          //System.err.println("fp += "+a+" ["+a.valeur()+"]");
+          fp.add(a);
+        }
+        while(! fp.isEmpty()){
+          System.err.println("FP_BEGIN");
+          for(Arc<Sommet> z : fp){
+            System.err.println(z+" "+z.valeur());
+          }
+          System.err.println("FP_END");
+          Arc<Sommet> a = fp.first();
+          fp.remove(a);
+          Sommet t = a.destination();
+          System.err.print("Je regarde "+a+"["+a.valeur()+"] : ");
+          if(HS.contains(t))
+            System.err.println("il forme un cycle");
+          else{
+            System.err.println("je l'ajoute dans T");
+            HS.add(t);
+            for(Arc<Sommet> b : voisins(t)){
+              System.err.println("fp += "+b+" ["+b.valeur()+"]");
+              fp.add(b);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  //////////////////// BFS ////////////////////
+
+
+  final static int inexplore = 0, encours = 1, explore = 2;
+
+  public void bfs(HashMap<Sommet,Integer> etat, Sommet s){
+    LinkedList<Sommet> f = new LinkedList<Sommet>();
+
+    etat.put(s, encours);
+    f.addLast(s);
+    while(! f.isEmpty()){
+      Sommet t = f.removeFirst();
+      System.err.println("J'explore "+t);
+      for(Arc<Sommet> a : voisins(t)){
+        Sommet u = a.destination();
+        if(etat.get(u) == inexplore){
+          etat.put(u, encours);
+          f.addLast(u);
+        }
+      }
+      etat.put(t, explore);
+    }
+  }
+
+  public HashMap<Sommet,Integer> bfsDistance(Sommet s){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    LinkedList<Sommet> f = new LinkedList<Sommet>();
+    HashMap<Sommet,Integer> distance = 
+      new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> numero =
+      new HashMap<Sommet,Integer>();
+    int num = 0;
+
+    for(Sommet t : sommets()){
+      etat.put(t, inexplore);
+      distance.put(t, 0);
+      numero.put(t, 0);
+    }
+    etat.put(s, encours);
+    f.addLast(s);
+    numero.put(s, num++);
+    while(! f.isEmpty()){
+      Sommet t = f.removeFirst();
+      System.err.println("J'explore "+t);
+      for(Arc<Sommet> a : voisins(t)){
+        Sommet u = a.destination();
+        if(etat.get(u) == inexplore){
+          etat.put(u, encours);
+          f.addLast(u);
+          numero.put(u, num++);
+          System.err.println("num["+u+"]="+numero.get(u));
+          distance.put(u, distance.get(t) + 1);
+        }
+      }
+      etat.put(t, explore);
+    }
+    return distance;
+  }
+
+  public void composantesConnexesBFS(){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    for(Sommet s : sommets())
+      etat.put(s, inexplore);
+    int ncc = 0;
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore){
+        ncc++;
+        System.err.println("Composante "+ncc);
+        bfs(etat, s);
+      }
+  }
+  
+  public boolean bfsBiparti(HashMap<Sommet,Integer> etat, HashMap<Sommet,Integer> couleur, Sommet s){
+    LinkedList<Sommet> f = new LinkedList<Sommet>();
+    int c = 0; // la couleur
+
+    etat.put(s, encours);
+    couleur.put(s, c);
+    f.addLast(s);
+    while(! f.isEmpty()){
+      Sommet t = f.removeFirst();
+      System.err.println("J'explore "+t+" de couleur "+couleur.get(t));
+      // c <- couleur des voisins de t
+      c = 1 - couleur.get(t);
+      for(Arc<Sommet> a : voisins(t)){
+        Sommet u = a.destination();
+        if(etat.get(u) == inexplore){
+          etat.put(u, encours);
+          couleur.put(u, c);
+          f.addLast(u);
+        }
+        else if(couleur.get(u) != c){
+          System.err.println(u+" est de'ja` colorie' avec la mauvaise couleur");
+          return false;
+        }
+      }
+      etat.put(t, explore);
+    }
+    return true;
+  }
+
+  // n'a vraiment un sens que sur les graphes non oriente's connexes
+  public HashMap<Sommet,Integer> estBiparti(){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> couleur = new HashMap<Sommet,Integer>();
+    for(Sommet s : sommets())
+      etat.put(s, inexplore);
+    int ncc = 0;
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore){
+        ncc++;
+        System.err.println("Composante "+ncc);
+        if(!bfsBiparti(etat, couleur, s))
+          // le graphe n'est pas biparti
+          return null;
+      }
+    return couleur;
+  }
+
+////////////DFS
+
+  public void dfs(HashMap<Sommet,Integer> etat, Sommet s){
+    LinkedList<Sommet> F = new LinkedList<Sommet>();
+    int rg = -1;
+
+    F.addFirst(s);
+    while(! F.isEmpty()){
+      Sommet t = F.removeFirst();
+      if(etat.get(t) != explore){
+      	System.err.println("J'explore "+t);
+      	etat.put(t, encours);
+      	++rg;
+      	System.err.println("rang["+t+"]="+rg);
+      	for(Arc<Sommet> a : voisins(t)){
+      		Sommet u = a.destination();
+      		F.addFirst(u);
+        }
+      }
+      etat.put(t, explore);
+    }
+  }
+
+  public void dfs(){
+  	Sommet r = null;
+  	for(Sommet s : sommets()){
+  		r = s;
+  		break;
+  	}
+  	HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+  	for(Sommet s : sommets())
+  		etat.put(s, inexplore);
+  	//dfsFausse(etat, r); // pour avoir un exemple qui foire Data/pchassignet.in
+  	dfs(etat, r);
+  }
+  
+  public int dfsRec(HashMap<Sommet,Integer> etat,
+                    HashMap<Arc<Sommet>,String> etat_a,
+                    HashMap<Sommet,Integer> rang, int rg,
+                    Sommet racine, Sommet s){
+    etat.put(s, encours);
+    rang.put(s, rg++);
+    System.err.println("J'explore "+s);
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat.get(t) == inexplore){
+        System.err.println("("+s+", "+t+") liaison");
+        etat_a.put(a, "arcliaison");
+        rg = dfsRec(etat, etat_a, rang, rg, racine, t);
+      }
+      else{
+        if(etat.get(t) == encours){
+          // t est ascendant de s
+          System.err.println("("+s+", "+t+") arrie`re");
+          etat_a.put(a, "arcarriere");
+        }
+        else{
+          // t a de'ja` e'te' explore'
+          if(rang.get(t) < rang.get(racine)){
+            System.err.println("("+s+", "+t+") transverse car racine("+t+") <> racine("+s+")");
+            etat_a.put(a, "arcinter");
+          }
+          else{ // t est dans la me^me arborescence que s
+            if(rang.get(s) < rang.get(t)){
+              System.err.println("("+s+", "+t+") avant");
+              etat_a.put(a, "arcavant");
+            }
+            else{
+              System.err.println("("+s+", "+t+") transverse");
+              etat_a.put(a, "arcintra");
+            }
+          }
+        }
+      }
+    }
+    etat.put(s, explore);
+    return rg;
+  }
+
+  public void dfsRang(){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    HashMap<Arc<Sommet>,String> etat_a = new HashMap<Arc<Sommet>,String>();
+    HashMap<Sommet,Integer> rang = new HashMap<Sommet,Integer>();
+
+    for(Sommet s : sommets()){
+      etat.put(s, inexplore);
+      for(Arc<Sommet> alpha : voisins(s))
+        etat_a.put(alpha, "arclibre");
+    }
+    int rg = 0;
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore)
+        rg = dfsRec(etat, etat_a, rang, rg, s, s);
+    System.err.print("       ");
+    for(Sommet t : sommets())
+      System.err.print(t);
+    System.err.print("\nrang   ");
+    for(Sommet t : sommets())
+      System.err.print(rang.get(t));
+    System.err.println();
+  }
+
+  // on retourne un arbre couvrant de racine s
+  public Arbre dfsRec(HashMap<Sommet,Integer> etat, Sommet s){
+    etat.put(s, encours);
+    Arbre A = new Arbre(s);
+    System.err.println("J'explore "+s);
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat.get(t) == inexplore)
+        A.ajouterFils(dfsRec(etat, t));
+    }
+    etat.put(s, explore);
+    return A;
+  }
+
+  public void dfsCouvrant(){
+    Sommet ALPHA = new Sommet("ALPHA");
+    Arbre F = new Arbre(ALPHA);
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+
+    for(Sommet s : sommets())
+      etat.put(s, inexplore);
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore)
+        F.ajouterFils(dfsRec(etat, s));
+    System.err.println("F=\n"+F);
+  }
+
+  //// Tri topologique
+
+  boolean dfsTopo(HashMap<Sommet,Integer> etat,
+                  LinkedList<Sommet> L, Sommet s){
+    etat.put(s, encours);
+    System.err.println("J'explore "+s);
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat.get(t) == inexplore){
+        if(! dfsTopo(etat, L, t))
+          return false;
+      }
+      else if(etat.get(t) == encours){
+        // t est ascendant de s
+        System.err.println("("+s+", "+t+") arrie`re -> erreur");
+        return false;
+      }
+    }
+    etat.put(s, explore);
+    L.addFirst(s);
+    return true;
+  }
+
+  public void triTopologique(){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    for(Sommet s : sommets())
+      etat.put(s, inexplore);
+    for(Sommet s : sommets()){
+      if(etat.get(s) == inexplore){
+        LinkedList<Sommet> L = new LinkedList<Sommet>();
+        if(! dfsTopo(etat, L, s)){
+          System.err.println("Graphe avec circuit");
+          return;
+        }
+        for(Sommet t : L)
+          System.err.print(t+" -> ");
+        System.err.println();
+      }
+    }
+  }
+
+  //// Points d'attache
+  int dfsAttache(HashMap<Sommet,Integer> etat,
+                 HashMap<Sommet,Integer> rang, int rg,
+                 HashMap<Sommet,Integer> rat, Sommet racine, Sommet s){
+    etat.put(s, encours);
+    System.err.println("J'explore "+s);
+    rang.put(s, rg++);
+    int rats = rang.get(s), ratt;
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat.get(t) == inexplore){
+        rg = dfsAttache(etat, rang, rg, rat, racine, t);
+        ratt = rat.get(t);
+      }
+      else if(etat.get(t) == encours)
+        // (s, t) est un arc arrie`re
+        ratt = rang.get(t);
+      else if(rang.get(t) < rang.get(racine))
+        // (s, t) transverse inter
+        continue;
+      else // (s, t) avant ou transverse intra
+        ratt = rang.get(t);
+      // HERE: vrai? Cf. exemple bbc1 pour l semble faux...!
+      rats = Math.min(rats, ratt);
+    }
+    rat.put(s, rats);
+    etat.put(s, explore);
+    return rg;
+  }
+
+  public void pointsDAttache(){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> rang = new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> rat = new HashMap<Sommet,Integer>();
+
+    for(Sommet s : sommets())
+      etat.put(s, inexplore);
+    int rg = 0;
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore)
+        rg = dfsAttache(etat, rang, rg, rat, s, s);
+    System.err.println("Rangs");
+    for(Sommet s : sommets())
+      System.err.println(s+" "+rang.get(s));
+    System.err.println("Rangs d'attache");
+    for(Sommet s : sommets())
+      System.err.println(s+" "+rat.get(s));
+  }
+
+  //// Composantes fortement connexes
+
+  final static int libre = 0, empile = 1, exclus = 2, pointdentree = 3, dansCFC = 4;
+
+  int dfsCfc(HashMap<Sommet,Integer> etat,
+             HashMap<Sommet,Integer> etat_cfc,
+  		       HashMap<Arc<Sommet>,String> etat_a,
+             LinkedList<Sommet> pile,
+             HashMap<Sommet,Integer> rang, int rg,
+             HashMap<Sommet,Integer> rat, 
+             Sommet racine, Sommet s){
+    etat.put(s, encours);
+    System.err.println("J'explore "+s);
+    rang.put(s, rg++);
+    rat.put(s, rang.get(s));
+    pile.addFirst(s);
+    etat_cfc.put(s, empile);
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat_cfc.get(t) == inexplore){
+        System.err.println("("+s+", "+t+") liaison");
+        etat_a.put(a, "arcliaison");
+        rg = dfsCfc(etat, etat_cfc, etat_a, pile, rang, rg, rat, racine, t);
+        if(rat.get(t) < rat.get(s)){
+        	rat.put(s, rat.get(t));
+        }
+      }
+      else{
+        if(etat_cfc.get(t) == empile){
+          if(rang.get(t) > rang.get(s))
+            // (s, t) est avant
+            etat_a.put(a, "arcavant");
+          else{
+            // (s, t) est arriere ou intra-arbre
+            // t est dans C(s) car t descendant de s et s -> t
+            if(etat.get(t) == encours){
+              System.err.println("("+s+", "+t+") arrie`re");
+              etat_a.put(a, "arcarriere");
+            }
+            else{
+              System.err.println("("+s+", "+t+") intra-arbre");
+              etat_a.put(a, "arcintra");
+            }
+            System.err.println(t+" est dans C("+s+")");
+            if(rang.get(t) < rat.get(s))
+              rat.put(s, rang.get(t));
+          }
+        }
+        else{
+          // t est exclus
+          System.err.println(t+" exclus");
+          if(rang.get(t) < rang.get(racine))
+            // (s, t) est inter-arbre
+            etat_a.put(a, "arcinter");
+          else
+            etat_a.put(a, "arcintra");
+      	}
+      }
+    }
+    etat.put(s, explore);
+    System.err.print("rang["+s+"]="+rang.get(s));
+    System.err.println(" rat["+s+"]="+rat.get(s));
+    if(rat.get(s) == rang.get(s)){
+      // s est un point d'entre'e
+    	etat_cfc.put(s, pointdentree);
+    	for(Sommet u : pile){
+    		if(u.equals(s))
+    			break;
+    		etat_cfc.put(u, dansCFC);
+    	}
+      Sommet t;
+      System.err.print("CFC={");
+      do{
+        t = pile.removeFirst();
+        etat_cfc.put(t, exclus);
+        System.err.print(" "+t);
+      } while(! t.equals(s));
+      System.err.println(" }");
+    }
+    return rg;
+  }
+
+  public void cfc(){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> etat_cfc = new HashMap<Sommet,Integer>();
+    HashMap<Arc<Sommet>,String> etat_a = new HashMap<Arc<Sommet>, String>();
+    HashMap<Sommet,Integer> rang = new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> rat = new HashMap<Sommet,Integer>();
+    LinkedList<Sommet> pile = new LinkedList<Sommet>();
+
+    for(Sommet s : sommets()){
+      etat.put(s, inexplore);
+      etat_cfc.put(s, libre);
+      for(Arc<Sommet> alpha : voisins(s))
+      	etat_a.put(alpha, "arclibre");
+    }
+    int rg = 0;
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore)
+        rg = dfsCfc(etat, etat_cfc, etat_a, pile, rang, rg, rat, s, s);
+    System.err.println("Rangs");
+    for(Sommet s : sommets())
+      System.err.println(s+" "+rang.get(s));
+  }
+
+  //// Points d'articulation et blocs
+
+  void depiler(LinkedList<Arc<Sommet>> pile, Sommet s, Sommet t){
+    Sommet x, y;
+    System.err.print("Bloc = {");
+    do{
+      Arc<Sommet> a = pile.removeFirst();
+      x = a.origine();
+      y = a.destination();
+      System.err.print("("+x+", "+y+")");
+    } while(!x.equals(s) && !y.equals(t));
+    System.err.println("}");
+  }
+
+  void depiler(LinkedList<Arc<Sommet>> pile){
+    System.err.print("Bloc_racine = {");
+    while(! pile.isEmpty()){
+      Arc<Sommet> a = pile.removeFirst();
+      System.err.print("("+a.origine()+", "+a.destination()+")");
+    }
+    System.err.println("}");
+  }
+
+  // pere -> s
+  int dfsPda(LinkedList<Sommet> lpda,
+             HashMap<Sommet,Integer> etat,
+             LinkedList<Arc<Sommet>> pile,
+             HashMap<Sommet,Integer> rang, int rg,
+             HashMap<Sommet,Integer> rat, 
+             Sommet pere, Sommet s){
+    etat.put(s, encours);
+    System.err.println("J'explore "+s);
+    rang.put(s, rg++);
+    int rats = rang.get(s);
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat.get(t) == inexplore){
+        System.err.println("("+s+", "+t+") liaison");
+        pile.addFirst(a);
+        rg = dfsPda(lpda, etat, pile, rang, rg, rat, s, t);
+        rats = Math.min(rats, rat.get(t));
+        if(rat.get(t) >= rang.get(s)){
+          System.err.println(s+" est point d'articulation");
+          depiler(pile, s, t);
+          lpda.addFirst(s);
+        }
+      }
+      else if((rang.get(t) < rang.get(s)) && !t.equals(pere)){
+        System.err.println("("+s+", "+t+") arrie`re ou transverse");
+        pile.addFirst(a);
+        rats = Math.min(rats, rang.get(t));
+      }
+    }
+    rat.put(s, rats);
+    System.err.print("rang["+s+"]="+rang.get(s));
+    System.err.println(" rat["+s+"]="+rat.get(s));
+    etat.put(s, explore);
+    return rg;
+  }
+
+  // s est la racine de l'arborescence
+  int dfsPda(LinkedList<Sommet> lpda,
+             HashMap<Sommet,Integer> etat,
+             LinkedList<Arc<Sommet>> pile, 
+             HashMap<Sommet,Integer> rang, int rg,
+             HashMap<Sommet,Integer> rat, Sommet s){
+    etat.put(s, encours);
+    System.err.println("J'explore "+s);
+    rang.put(s, rg++);
+    int rats = rang.get(s);
+    int nfils = 0;
+    for(Arc<Sommet> a : voisins(s)){
+      Sommet t = a.destination();
+      if(etat.get(t) == inexplore){
+        System.err.println("("+s+", "+t+") liaison");
+        pile.addFirst(a);
+        rg = dfsPda(lpda, etat, pile, rang, rg, rat, s, t);
+        nfils++;
+      }
+    }
+    if(nfils > 1){
+      lpda.addFirst(s);
+      System.err.println(s+" est racine ET point d'articulation");
+      depiler(pile);
+    }
+    rat.put(s, rats);
+    System.err.print("rang["+s+"]="+rang.get(s));
+    System.err.println(" rat["+s+"]="+rat.get(s));
+    etat.put(s, explore);
+    return rg;
+  }
+
+  public void pointsDArticulation(LinkedList<Sommet> lpda,
+                                  HashMap<Sommet,Integer> rat){
+    HashMap<Sommet,Integer> etat = new HashMap<Sommet,Integer>();
+    HashMap<Sommet,Integer> rang = new HashMap<Sommet,Integer>();
+
+    for(Sommet s : sommets())
+      etat.put(s, inexplore);
+    int rg = 0;
+    LinkedList<Arc<Sommet>> pile = new LinkedList<Arc<Sommet>>();
+    for(Sommet s : sommets())
+      if(etat.get(s) == inexplore)
+        // nouvelle composante connexe
+        rg = dfsPda(lpda, etat, pile, rang, rg, rat, s);
+    System.err.println("Rangs");
+    for(Sommet s : sommets())
+      System.err.println(s+" "+rang.get(s));
+  }
+
+  public static String XMLHeader(){
+    String str = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    str += "<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\"\n";
+    str += "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n";
+    str += "xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns\n";
+    str += "http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd\">\n";
+    str += "  <key id=\"Pigale/version\" for=\"graph\" attr.name=\"Pigale version\" attr.type=\"string\">\n";
+    str += "    <default>1.3.9</default>\n";
+    str += "  </key>\n";
+    str += "  <key id=\"Pigale/V/16\" for=\"node\" attr.name=\"Coordinates\" attr.type=\"string\"/>\n";
+    str += "  <key id=\"Pigale/V/1\" for=\"node\" attr.name=\"Color\" attr.type=\"string\"/>\n";
+    str += "  <key id=\"Pigale/V/0\" for=\"node\" attr.name=\"Label\" attr.type=\"string\"/>\n";
+    str += "  <key id=\"Pigale/E/1\" for=\"edge\" attr.name=\"Color\" attr.type=\"string\"/>\n";
+    str += "  <key id=\"Pigale/E/16\" for=\"edge\" attr.name=\"Width\" attr.type=\"string\"/>\n";
+    return str;
+  }
+  public static String XMLTrailer(){
+    return "</graphml>\n";
+  }
+  // pos[s] est la position de s dans le plan, color[s] le contenu de s, par exemple une couleur.
+  // pos[s] doit etre de la forme x,y
+  public String toGraphml(String nom, HashMap<Sommet,String> pos, HashMap<Sommet,Integer> color){
+    String str = XMLHeader();
+    str += "  <graph id=\"" + nom + "\"";
+    if(oriente)
+      str += " edgedefault=\"directed\">\n";
+    else
+      str += " edgedefault=\"undirected\">\n";
+    // les sommets
+    for(Sommet s : sommets()){
+      str += "    <node id=\"" + s + "\">\n";
+      if(pos != null)
+        str += "      <data key=\"Pigale/V/16\">"+pos.get(s)+"</data>\n";
+      if(color != null)
+        str += "      <data key=\"Pigale/V/1\">" + color.get(s) + "</data>\n";
+      str += "      <data key=\"Pigale/V/0\">" + s + "</data>\n";
+      str += "    </node>\n";
+    }
+    // les aretes
+    for(Sommet s : sommets()){
+      for(Arc<Sommet> arc : voisins(s)){
+        // TODO: permettre des couleurs et labels sur les arcs
+        Sommet t = arc.destination();
+        str += "    <edge source=\""+s+"\" target=\""+t+"\">\n";
+        str += "      <data key=\"Pigale/E/1\">1</data>\n";
+        str += "      <data key=\"Pigale/E/16\">1</data>\n";
+        str += "    </edge>\n";
+      }
+    }
+    str += "  </graph>\n";
+    str += XMLTrailer();
+    return str;
+  }*/
+}
+

2020-2021/src/TD6/grapheX/GrapheGenerique.java

@@ -0,0 +1,81 @@
+package TD6.grapheX;
+
+import java.util.Collection;
+
+/**
+ * Super-classe abstraite des graphes, les sommets doivent <EFBFBD>tre identifiables.
+ * 
+ * @author FMorain (morain@lix.polytechnique.fr)
+ * @author PChassignet (chassign@lix.polytechnique.fr)
+ * @version 2007.03.21
+ */
+
+public abstract class GrapheGenerique<S extends Identifiable> {
+
+  /**
+   * @return le nombre de sommets de ce graphe.
+   */
+  public abstract int taille();
+
+  /**
+   * @param s
+   *          le sommet <EFBFBD> ajouter <EFBFBD> ce graphe.
+   */
+  public abstract void ajouterSommet(S s);
+
+  /**
+   * @return une <tt>Collection</tt> de tous les sommets de ce graphe.
+   */
+  public abstract Collection<S> sommets();
+
+  /**
+   * Teste l'existence de l'arc de <tt>s</tt> <EFBFBD> <tt>t</tt> dans ce graphe.
+   * 
+   * @param s
+   *          l'origine de l'arc,
+   * @param t
+   *          l'extr<EFBFBD>mit<EFBFBD> de l'arc.
+   */
+  public abstract boolean existeArc(S s, S t);
+
+  /**
+   * @param s
+   *          l'origine de l'arc,
+   * @param t
+   *          l'extr<EFBFBD>mit<EFBFBD> de l'arc,
+   * @param val
+   *          une valeur enti<EFBFBD>re attach<EFBFBD>e <EFBFBD> l'arc de <tt>s</tt> <EFBFBD> <tt>t</tt>
+   *          dans ce graphe.
+   */
+  public abstract void ajouterArc(S s, S t, int val);
+
+  /**
+   * @param s
+   *          l'origine de l'arc,
+   * @param t
+   *          l'extr<EFBFBD>mit<EFBFBD> de l'arc.
+   * @return la valeur enti<EFBFBD>re attach<EFBFBD>e <EFBFBD> l'arc de <tt>s</tt> <EFBFBD> <tt>t</tt>
+   *         dans ce graphe.
+   */
+  public abstract int valeurArc(S s, S t);
+
+  /**
+   * Supprime l'arc de <tt>s</tt> <EFBFBD> <tt>t</tt> dans ce graphe.
+   * 
+   * @param s
+   *          l'origine de l'arc,
+   * @param t
+   *          l'extr<EFBFBD>mit<EFBFBD> de l'arc.
+   */
+  public abstract void enleverArc(S s, S t);
+
+  /**
+   * @param s
+   *          l'origine des arcs.
+   * @return une <tt>Collection</tt> de tous les arcs de ce graphe ayant
+   *         <tt>s</tt> pour origine. Ces arcs sont de type
+   *         <tt>Arc&lt;S&gt;</tt>.
+   */
+  public abstract Collection<Arc<S>> voisins(S s);
+  
+}

2020-2021/src/TD6/grapheX/Identifiable.java

@@ -0,0 +1,100 @@
+package TD6.grapheX;
+
+/**
+ * Définit des objets identifiés par une <tt>String</tt>. Deux objets
+ * <tt>Identifiable</tt> qui sont construit avec le même identifiant seront
+ * considérés comme identiques pour les méthodes <tt>hashCode</tt>,
+ * <tt>equals</tt> et <tt>compareTo</tt>. Cette classe sert notamment de
+ * super-classe pour les sommets d'un graphe.
+ * 
+ * @author PChassignet (chassign@lix.polytechnique.fr)
+ * @version 2007.03.21
+ */
+
+public class Identifiable implements Comparable<Identifiable> {
+  private final String ident;
+
+  /**
+   * @param identifiant
+   *          l'identifiant pour cet objet.
+   */
+  public Identifiable(String identifiant) {
+    ident = identifiant;
+  }
+
+  /**
+   * @return l'identifiant pour cet objet.
+   */
+  public final String identifiant() {
+    return ident;
+  }
+
+  /**
+   * @return le <tt>hashCode</tt> de l'identifiant de cet objet.
+   */
+  @Override
+public final int hashCode() {	
+    if (ident == null)
+      return 0;
+    else
+      return ident.hashCode();
+  }
+
+  /**
+   * @return le résultat de <tt>equals</tt> sur les identifiants.
+   */
+  @Override
+public final boolean equals(Object o) {
+    if (!(o instanceof Identifiable)) {
+      return false;
+    }
+    String oid = ((Identifiable) o).ident;
+    if (ident == null)
+      return oid == null;
+    else
+      return ident.equals(oid);
+  }
+
+  /**
+   * @return le résultat de <tt>compareTo</tt> sur les identifiants.
+   */
+public final int compareTo(Identifiable id) {	 	 
+    if (ident == null)
+      if (id.ident == null)
+        return 0;
+      else
+        return -1;
+    else if (id.ident == null)
+      return 1;
+    else
+      return ident.compareTo(id.ident);
+  }
+
+  /**
+   * @param id1
+   *          premier objet à comparer,
+   * @param id2
+   *          second objet à comparer,
+   * @return le résultat de <tt>id1.compareTo(id2)</tt>.
+   */
+  public static final int compare(Identifiable id1, Identifiable id2) {
+    if (id1 == null)
+      if (id2 == null)
+        return 0;
+      else
+        return -1;
+    else if (id2 == null)
+      return 1;
+    else
+      return id1.compareTo(id2);
+  }
+
+  @Override
+public String toString() {
+    if (ident == null)
+      return "[null]";
+    else
+      return "[\"" + ident + "\"]";
+  }
+
+}

2020-2021/src/TD6/grapheX/Sommet.java

@@ -0,0 +1,23 @@
+package TD6.grapheX;
+
+/**
+ * Classe de sommets, toutes les propriétés sont héritées de Identifiable.
+ * 
+ * @author FMorain (morain@lix.polytechnique.fr)
+ * @author PChassignet (chassign@lix.polytechnique.fr)
+ * @version 2007.03.21
+ */
+
+public class Sommet extends Identifiable {
+
+  public Sommet(String nn) {
+    super(nn);
+  }
+
+  @Override
+public String toString() {
+    return identifiant();
+  }
+
+  
+}

2020-2021/src/TD6/grapheX/SommetValue.java

@@ -0,0 +1,11 @@
+package TD6.grapheX;
+
+public class SommetValue {
+  Sommet s;
+  int valeur;
+  
+  SommetValue(Sommet ss, int vv){
+    s = ss;
+    valeur = vv;
+  }
+}

2020-2021/src/TD6/reseauSocial/core/MemberInterface.java

@@ -0,0 +1,9 @@
+package TD6.reseauSocial.core;
+
+public interface MemberInterface {
+
+
+	public String getLocation();
+	public void setLocation(String s);
+	public String getName();
+}

2020-2021/src/TD6/reseauSocial/core/SocialNetworkInterface.java

@@ -0,0 +1,74 @@
+package TD6.reseauSocial.core;
+
+
+import java.beans.PropertyChangeListener;
+import java.util.Collection;
+import java.util.Observer;
+import java.util.Set;
+
+import TD6.facebookGhost.FacebookGhostNetwork;
+
+/**
+ * 
+ * Basic" interface for defining a social network
+ * 
+ * @author blay
+ *
+ */
+
+public interface SocialNetworkInterface<T>  {
+
+	/**
+	 * @param identifier for a member
+	 * @return member if known by the network
+	 */
+	public T getMember(String identifier);
+
+	/**
+	 * @return the set of members belonging to the network
+	 */
+	public Collection<T> getMembers();
+
+	/**
+	 * add a member to the network
+	 */
+	public void addMember(T membre);
+
+	/**
+	 * @param ident
+	 * @param fg a facebookGhostNetwork, if the member belongs to fg, an adapter to this network is created.
+	 * @return the member corresponding to the identifier. If a member with this identifer already exists, the member is not created.
+	 */
+	public T addMember(String ident, FacebookGhostNetwork fg);
+	public T addMember(String identifier);
+	
+
+	/**
+	 * 
+	 * Add the relationship between a member and a friend with a given force.
+	 * 
+	 * @param force
+	 * @param member
+	 * @param friend
+	 * 
+	 */
+	public void relate(Strength force, T member, T friend);
+
+	/**
+	 * @param member
+	 * @param rank
+	 * @return returns all members given the rank (at rank 1 : direct neighbors; at rank 2 :  neighbors of neighbors.
+	 * A member appears at the lowest rank, it does not appear in a higher rank
+	 */
+	public Set<T> relatedToRank(T member, int rank);
+
+	/**
+	 * @param member1
+	 * @param member2
+	 * @return distance between the two members
+	 */
+	public int distance(T member1, T member2);
+
+
+
+}

2020-2021/src/TD6/reseauSocial/core/Strength.java

@@ -0,0 +1,17 @@
+package TD6.reseauSocial.core;
+
+public enum Strength {
+	LOW (4), MEDIUM (3), HIGH (2), STRONG(1);
+	
+	int value;
+	
+	public int getValue() {
+		return value;
+	}
+
+	Strength( int pvalue){
+		value = pvalue;
+	}
+	
+	
+}

2020-2021/src/TD7/armes/Arme.java

@@ -0,0 +1,45 @@
+package TD7.armes;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public abstract class Arme {
+	
+	private int force;
+	private int protection;
+	
+	public Arme(int f, int p) {
+		this.setForce(f);
+		this.setProtection(p);
+	}
+	
+	/**
+	 * @return the force
+	 */
+	public int getForce() {
+		return force;
+	}
+	/**
+	 * @return the protection
+	 */
+	public int getProtection() {
+		return protection;
+	}
+	/**
+	 * @param force the force to set
+	 */
+	private void setForce(int force) {
+		this.force = force;
+	}
+	/**
+	 * @param protection the protection to set
+	 */
+	private void setProtection(int protection) {
+		this.protection = protection;
+	}
+
+
+}

2020-2021/src/TD7/armes/Bouclier.java

@@ -0,0 +1,20 @@
+package TD7.armes;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Bouclier extends Arme {
+
+	public Bouclier() {
+		this(5, 20);
+	}
+	
+	private Bouclier(int f, int p) {
+		super(f, p);
+		// TODO Auto-generated constructor stub
+	}
+
+}

2020-2021/src/TD7/armes/Dague.java

@@ -0,0 +1,19 @@
+package TD7.armes;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Dague extends Arme {
+
+	public Dague() {
+		this(20, 10);
+	}
+	
+	private Dague(int f, int p) {
+		super(f, p);
+	}
+
+}

2020-2021/src/TD7/armes/Epee.java

@@ -0,0 +1,19 @@
+package TD7.armes;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Epee extends Arme {
+
+	public Epee() {
+		this(25, 5);
+	}
+	
+	private Epee(int f, int p) {
+		super(f, p);
+	}
+
+}

2020-2021/src/TD7/personnages/Elfe.java

@@ -0,0 +1,35 @@
+package TD7.personnages;
+
+import TD7.armes.Epee;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Elfe extends Personnage {
+
+	private String accuite;
+	
+	public Elfe(String n, String a) {
+		super(n);
+		this.setArmeCourante(new Epee());
+		this.setAccuite(a);
+	}
+
+	/**
+	 * @param accuite the accuite to set
+	 */
+	private void setAccuite(String accuite) {
+		this.accuite = accuite;
+	}
+
+	/**
+	 * @return the accuite
+	 */
+	public String getAccuite() {
+		return accuite;
+	}
+
+}

2020-2021/src/TD7/personnages/Orc.java

@@ -0,0 +1,35 @@
+package TD7.personnages;
+
+import TD7.armes.Epee;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Orc extends Personnage {
+
+	private int fureur;
+	
+	public Orc(String n, int f) {
+		super(n);
+		this.setArmeCourante(new Epee());
+		this.setFureur(f);
+	}
+
+	/**
+	 * @return the fureur
+	 */
+	public int getFureur() {
+		return fureur;
+	}
+
+	/**
+	 * @param fureur the fureur to set
+	 */
+	private void setFureur(int fureur) {
+		this.fureur = fureur;
+	}
+
+}

2020-2021/src/TD7/personnages/Personnage.java

@@ -0,0 +1,148 @@
+package TD7.personnages;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import TD7.armes.Arme;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public abstract class Personnage {
+	
+	private String nom;
+	private int maxHp;
+	private int hp;
+	private List<Arme> armes;
+	private Arme armeCourante; 
+	
+	public Personnage(String s) {
+		this.setNom(s);
+		this.setMaxHp(100);
+		this.setHp(this.getMaxHp());
+		this.setArmes(new ArrayList<Arme>());
+		this.setArmeCourante(null);
+	}
+
+	public void vielli() {
+		this.vielli(1);
+	}
+	
+	public void vielli(int value) {
+		this.setMaxHp(this.getMaxHp()-value);
+	}
+	
+	public void ajouterArme(Arme a) {
+		if(this.armeCourante != null) {
+			this.armes.add(this.getArmeCourante());
+		}
+		this.setArmeCourante(a);
+	}
+	
+	public int getForce() {
+		return this.armeCourante.getForce();
+	}
+	
+	public int getProtection() {
+		return this.armeCourante.getProtection();
+	}
+	
+	private void getDamage(int a) {
+		int calcul = this.hp - a;
+		
+		if(calcul <= 0) {
+			this.setHp(0);
+		} else {
+			this.setHp(calcul);
+		}
+	}
+	
+	public void attaquer(Personnage p) {
+		int damage = this.getForce() - p.getProtection();
+		
+		if(damage > 0) {
+			System.out.print(this.getNom() + this.getHp() + " a attaqué " + p.getNom()  + p.getHp() + ".");
+			p.getDamage(damage);
+			System.out.println(" " + p.getNom() + " a perdu " + damage + " HP" + p.getHp() + "!");
+		} else {
+			System.out.println(this.getNom() + " a attaqué " + p.getNom() +" et n'a pris aucun dégats.");
+		}
+		
+		
+	}
+	
+	/**
+	 * @return the nom
+	 */
+	public String getNom() {
+		return nom;
+	}
+
+	/**
+	 * @param nom the nom to set
+	 */
+	private void setNom(String nom) {
+		this.nom = nom;
+	}
+
+	/**
+	 * @return the hp
+	 */
+	public int getHp() {
+		return hp;
+	}
+
+	/**
+	 * @param hp the hp to set
+	 */
+	private void setHp(int hp) {
+		this.hp = hp;
+	}
+
+	/**
+	 * @return the maxHp
+	 */
+	public int getMaxHp() {
+		return maxHp;
+	}
+
+	/**
+	 * @param maxHp the maxHp to set
+	 */
+	private void setMaxHp(int maxHp) {
+		this.maxHp = maxHp;
+	}
+
+	/**
+	 * @return the armes
+	 */
+	public List<Arme> getArmes() {
+		return armes;
+	}
+
+	/**
+	 * @return the armeCourante
+	 */
+	public Arme getArmeCourante() {
+		return armeCourante;
+	}
+
+	/**
+	 * @param armes the armes to set
+	 */
+	private void setArmes(List<Arme> armes) {
+		this.armes = armes;
+	}
+
+	/**
+	 * @param armeCourante the armeCourante to set
+	 */
+	protected void setArmeCourante(Arme armeCourante) {
+		this.armeCourante = armeCourante;
+	}
+	
+	
+}

2020-2021/src/TD7/personnages/Tauren.java

@@ -0,0 +1,35 @@
+package TD7.personnages;
+
+import TD7.armes.Bouclier;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Tauren extends Personnage {
+
+	private int muscle;
+	
+	public Tauren(String n, int m) {
+		super(n);
+		this.setArmeCourante(new Bouclier());
+		this.setMuscle(m);
+	}
+
+	/**
+	 * @return the muscle
+	 */
+	public int getMuscle() {
+		return muscle;
+	}
+
+	/**
+	 * @param muscle the muscle to set
+	 */
+	private void setMuscle(int muscle) {
+		this.muscle = muscle;
+	}
+
+}

2020-2021/src/TD7/personnages/Troll.java

@@ -0,0 +1,29 @@
+package TD7.personnages;
+
+import TD7.armes.Dague;
+
+/**
+ * @ Author: CrewmateGroup (Kitabdjian Léo - Longuemare Hugo - Rizzo Michael - Srifi Pauline)
+ * @ Copyright: Creative Common 4.0 (CC BY 4.0)
+ * @ Create Time: 25-11-2020 13:50
+ */
+
+public class Troll extends Personnage {
+
+	private String regen;
+	
+	public Troll(String n, String r) {
+		super(n);
+		this.setArmeCourante(new Dague());
+		this.setRegen(r);
+	}
+
+	public String getRegen() {
+		return regen;
+	}
+
+	private void setRegen(String regen) {
+		this.regen = regen;
+	}
+
+}

2020-2021/src/td6.ucls

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<class-diagram version="1.2.4" icons="true" always-add-relationships="false" generalizations="true" realizations="true" 
+  associations="true" dependencies="false" nesting-relationships="true" router="FAN">  
+  <class id="1" language="java" name="TD6.grapheX.Arc" project="M315" file="/M315/src/TD6/grapheX/Arc.java" 
+    binary="false" corner="BOTTOM_RIGHT">    
+    <position height="-1" width="-1" x="244" y="134"/>    
+    <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+      sort-features="false" accessors="true" visibility="true">      
+      <attributes public="true" package="true" protected="true" private="true" static="true"/>      
+      <operations public="true" package="true" protected="true" private="true" static="true"/>    
+    </display>  
+  </class>  
+  <class id="2" language="java" name="TD6.grapheX.GrapheGenerique" project="M315" 
+    file="/M315/src/TD6/grapheX/GrapheGenerique.java" binary="false" corner="BOTTOM_RIGHT">    
+    <position height="-1" width="-1" x="660" y="128"/>    
+    <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+      sort-features="false" accessors="true" visibility="true">      
+      <attributes public="true" package="true" protected="true" private="true" static="true"/>      
+      <operations public="true" package="true" protected="true" private="true" static="true"/>    
+    </display>  
+  </class>  
+  <class id="3" language="java" name="TD6.grapheX.Sommet" project="M315" file="/M315/src/TD6/grapheX/Sommet.java" 
+    binary="false" corner="BOTTOM_RIGHT">    
+    <position height="-1" width="-1" x="395" y="697"/>    
+    <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+      sort-features="false" accessors="true" visibility="true">      
+      <attributes public="true" package="true" protected="true" private="true" static="true"/>      
+      <operations public="true" package="true" protected="true" private="true" static="true"/>    
+    </display>  
+  </class>  
+  <class id="4" language="java" name="TD6.grapheX.Graphe" project="M315" file="/M315/src/TD6/grapheX/Graphe.java" 
+    binary="false" corner="BOTTOM_RIGHT">    
+    <position height="-1" width="-1" x="660" y="519"/>    
+    <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+      sort-features="false" accessors="true" visibility="true">      
+      <attributes public="true" package="true" protected="true" private="true" static="true"/>      
+      <operations public="true" package="true" protected="true" private="true" static="true"/>    
+    </display>  
+  </class>  
+  <class id="5" language="java" name="TD6.grapheX.Identifiable" project="M315" 
+    file="/M315/src/TD6/grapheX/Identifiable.java" binary="false" corner="BOTTOM_RIGHT">    
+    <position height="-1" width="-1" x="243" y="438"/>    
+    <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+      sort-features="false" accessors="true" visibility="true">      
+      <attributes public="true" package="true" protected="true" private="true" static="true"/>      
+      <operations public="true" package="true" protected="true" private="true" static="true"/>    
+    </display>  
+  </class>  
+  <class id="6" language="java" name="TD6.grapheX.SommetValue" project="M315" 
+    file="/M315/src/TD6/grapheX/SommetValue.java" binary="false" corner="BOTTOM_RIGHT">    
+    <position height="-1" width="-1" x="456" y="384"/>    
+    <display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+      sort-features="false" accessors="true" visibility="true">      
+      <attributes public="true" package="true" protected="true" private="true" static="true"/>      
+      <operations public="true" package="true" protected="true" private="true" static="true"/>    
+    </display>  
+  </class>  
+  <association id="7">    
+    <end type="SOURCE" refId="1" navigable="false">      
+      <attribute id="8" name="d"/>      
+      <multiplicity id="9" minimum="0" maximum="1"/>    
+    </end>    
+    <end type="TARGET" refId="5" navigable="true"/>    
+    <display labels="true" multiplicity="true"/>  
+  </association>  
+  <association id="10">    
+    <end type="SOURCE" refId="6" navigable="false">      
+      <attribute id="11" name="s"/>      
+      <multiplicity id="12" minimum="0" maximum="1"/>    
+    </end>    
+    <end type="TARGET" refId="3" navigable="true"/>    
+    <display labels="true" multiplicity="true"/>  
+  </association>  
+  <generalization id="13">    
+    <end type="SOURCE" refId="3"/>    
+    <end type="TARGET" refId="5"/>  
+  </generalization>  
+  <generalization id="14">    
+    <end type="SOURCE" refId="4"/>    
+    <end type="TARGET" refId="2"/>  
+  </generalization>  
+  <association id="15">    
+    <end type="SOURCE" refId="1" navigable="false">      
+      <attribute id="16" name="o"/>      
+      <multiplicity id="17" minimum="0" maximum="1"/>    
+    </end>    
+    <end type="TARGET" refId="5" navigable="true"/>    
+    <display labels="true" multiplicity="true"/>  
+  </association>  
+  <classifier-display autosize="true" stereotype="true" package="true" initial-value="false" signature="true" 
+    sort-features="false" accessors="true" visibility="true">    
+    <attributes public="true" package="true" protected="true" private="true" static="true"/>    
+    <operations public="true" package="true" protected="true" private="true" static="true"/>  
+  </classifier-display>  
+  <association-display labels="true" multiplicity="true"/>
+</class-diagram>

2020-2021/tests/TD6/grapheSimple/GrapheSimpleTest.java

@@ -0,0 +1,238 @@
+package TD6.grapheSimple;
+
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import TD6.grapheX.Arc;
+import TD6.grapheX.Sommet;
+
+
+//@todo to be improved!
+public class GrapheSimpleTest extends GrapheSimple<Sommet> {
+
+	
+	GrapheSimple<Sommet> graphe = new GrapheSimple<>();
+	Sommet s1 = new Sommet("S1");
+	Sommet s2 = new Sommet("S2");
+	Sommet s3= new Sommet("S3");
+	Sommet s4= new Sommet("S4");
+	int distance_s1_s2 = 1;
+	int distance_s1_s3 = 2;
+	int distance_s2_s1 = 2;
+	int distance_s2_s3 = 1;
+	int distance_s3_s4 = 2;	
+	int distance_s4_s1 = 10;
+	
+	
+	/*
+	 * s1 -1-> s2 -1-> s3
+	 * s2-2-> s1 
+	 * s3 -2-> s4
+	 * s4 -10-> s1
+	 * 
+	 */
+	@BeforeEach
+	public void setUp() throws Exception {
+		graphe = new GrapheSimple<>();
+		
+	}
+	
+	public void initGlobalGraph(){
+		graphe = new GrapheSimple<>();
+		graphe.ajouterSommet(s1);
+		graphe.ajouterSommet(s2);
+		graphe.ajouterSommet(s3);
+		graphe.ajouterSommet(s4);
+		graphe.ajouterArc(s1, s2, distance_s1_s2);
+		graphe.ajouterArc(s1, s2, distance_s1_s2*2);
+		graphe.ajouterArc(s1, s3, distance_s1_s3);
+		graphe.ajouterArc(s2, s1, distance_s2_s1);
+		graphe.ajouterArc(s2, s3, distance_s2_s3);
+		graphe.ajouterArc(s3, s4, distance_s3_s4);		
+		graphe.ajouterArc(s4, s1, distance_s4_s1);
+	}
+
+
+
+	
+	@Test
+	public void testTailleInitiale() {
+		assertEquals(0,graphe.taille());
+	}
+
+	@Test
+	public void testAjouterSommetInitial() {
+		graphe.ajouterSommet(s1);
+		assertEquals(1,graphe.taille());
+		assertEquals(s1,graphe.getSommet("S1"));
+	}
+	
+	@Test
+	public void testAjouterArcInitial() {
+		graphe.ajouterSommet(s1);
+		graphe.ajouterSommet(s2);
+		graphe.ajouterSommet(s3);
+		graphe.ajouterArc(s1, s2, distance_s1_s2);
+		assertEquals(3,graphe.taille());
+		assertTrue(graphe.existeArc(s1, s2));
+		assertFalse(graphe.existeArc(s1, s3));
+		List<Arc<Sommet>> arcs = graphe.arcs(s1, s2);
+		assertEquals(1,arcs.size());
+	}
+
+
+
+	@Test
+	public void testVoisinsSommet() {
+		initGlobalGraph();
+		Collection<Arc<Sommet>> voisins = graphe.voisins(s1);
+		assertEquals(3, voisins.size());
+		//System.out.println("voisins de s1 :" + voisins);
+		voisins = graphe.voisins(s2);
+		assertEquals(2, voisins.size(), "voisins de s2 : " + voisins);
+		//System.out.println("voisins de s2 : " + voisins);
+	}
+
+	@Test
+	public void testArcs() {
+		initGlobalGraph();
+		List<Arc<Sommet>> arcs = graphe.arcs(s1, s2);
+		//System.out.println("de s1 a s2 : " + arcs);
+		assertEquals(2, arcs.size());
+		arcs = graphe.arcs(s1, s3);
+		//System.out.println("de s1 a s3 : " + arcs);
+		assertEquals(1, arcs.size());
+		arcs = graphe.arcs(s1, s4);
+		//System.out.println("de s1 a s4 : " + arcs);
+		assertTrue(arcs==null);
+		arcs = graphe.arcs(s4, s1);
+		//System.out.println("de s4 a s1 : " + arcs);
+		assertEquals(1, arcs.size());
+		
+	}
+	
+	@Test
+	public void testParcoursCheminsDe() {
+		initGlobalGraph();
+		List<Chemin<Sommet>> chemins = graphe.chemins(s1);
+		assertEquals(3, chemins.size());
+		System.out.println("Chemins a partir de s1: " + chemins);
+		chemins = graphe.chemins(s2);
+		System.out.println("Chemins a partir de s2: " + chemins);
+		assertEquals(2, chemins.size());
+		chemins = graphe.chemins(s3);
+		System.out.println("Chemins a partir de s3: " + chemins);
+		assertEquals(2, chemins.size());
+		chemins = graphe.chemins(s4);
+		assertEquals(3, chemins.size());
+		System.out.println("Chemins a partir de s4: " + chemins);
+	}
+	
+	@Test
+	public void testParcoursCheminsDeA() {
+		initGlobalGraph();
+		List<Chemin<Sommet>> chemins = graphe.chemins(s1,s2);
+		System.out.println("Chemins de s1 a s2: " + chemins);
+		assertEquals(2, chemins.size());
+
+		chemins = graphe.chemins(s1,s3);
+		System.out.println("Chemins de s1 a s3: " + chemins);
+		assertEquals(3, chemins.size(), "Chemins de s1 a s3:");
+		chemins = graphe.chemins(s1,s4);
+		System.out.println("Chemins  de s1 a s4: " + chemins);
+		assertEquals(3, chemins.size());
+		chemins = graphe.chemins(s2,s3);
+		System.out.println("Chemins de s2 a s3: " + chemins);
+		assertEquals(2, chemins.size());
+		chemins = graphe.chemins(s4,s1);
+		System.out.println("Chemins  de s4 a s1: " + chemins);
+		assertEquals(1, chemins.size(), "Chemins  de s4 a s1: ");
+		
+	}
+	
+	@Test
+	public void testCheminLePlusCourt() {
+		initGlobalGraph();
+		Chemin<Sommet> chemin = graphe.cheminLePlusCourt(s1, s2);
+		assertEquals(distance_s1_s2, chemin.distance());
+		chemin = graphe.cheminLePlusCourt(s1, s3);
+		assertEquals(distance_s1_s3, chemin.distance());
+		chemin = graphe.cheminLePlusCourt(s1, s4);
+		assertEquals(4, chemin.distance());
+		chemin = graphe.cheminLePlusCourt(s2, s3);
+		assertEquals(distance_s2_s3, chemin.distance());
+		chemin = graphe.cheminLePlusCourt(s4, s1);
+		assertEquals(distance_s4_s1, chemin.distance());
+	}
+	
+	@Test
+	public void testVoisinsDeRangs() {
+		initGlobalGraph();
+		Set<Sommet> voisins = graphe.voisinsAuRang(s1, 1);
+		System.out.println("voisins s1 au rang 1: " + voisins);
+		assertEquals(2, voisins.size());
+		assertTrue(voisins.contains(s2));
+		assertTrue(voisins.contains(s3));
+		voisins = graphe.voisinsAuRang(s1, 2);
+		System.out.println("voisins s1 au rang 2: " + voisins);
+		assertEquals(1, voisins.size());
+		assertTrue(voisins.contains(s4));
+		voisins = graphe.voisinsAuRang(s2, 1);
+		System.out.println("voisins s2 au rang 1: " + voisins);
+		assertEquals(2, voisins.size());
+		assertTrue(voisins.contains(s1));
+		assertTrue(voisins.contains(s3));
+		voisins = graphe.voisinsAuRang(s2, 2);
+		System.out.println("voisins s2 au rang 2: " + voisins);
+		assertEquals(1, voisins.size());
+		assertTrue(voisins.contains(s4));
+		voisins = graphe.voisinsAuRang(s4, 2);
+		System.out.println("voisins s4 au rang 2: " + voisins);
+		assertEquals(2, voisins.size());
+		assertTrue(voisins.contains(s2));
+		assertTrue(voisins.contains(s3));
+	}
+	
+	
+	@Test
+	public void testExtraireChemin() {
+		Chemin<Sommet> cheminComplet = new Chemin<>();
+		cheminComplet.add(new Arc<Sommet>(s1,s2));
+		cheminComplet.add(new Arc<Sommet>(s2,s3));
+		cheminComplet.add(new Arc<Sommet>(s3,s4));
+		System.out.println("chemin de s1 a s4 " + cheminComplet);
+		Chemin<Sommet> c= cheminComplet.extraireChemin(s1, s4);
+		System.out.println("chemin de s1 a s4 apres extraction " + c);
+		assertEquals(3,c.getArcs().size());
+		assertEquals(s1,c.getArcs().get(0).origine());
+		assertEquals(s4,c.getArcs().get(2).destination());
+		
+		c= cheminComplet.extraireChemin(s1, s3);
+		System.out.println("chemin de s1 a s3 apres extraction " + c);
+		assertEquals(2,c.getArcs().size());
+		assertEquals(s1,c.getArcs().get(0).origine());
+		assertEquals(s3,c.getArcs().get(1).destination());
+		
+		c= cheminComplet.extraireChemin(s2, s3);
+		System.out.println("chemin de s2 a s3 apres extraction " + c);
+		assertEquals(1,c.getArcs().size());
+		assertEquals(s2,c.getArcs().get(0).origine());
+		assertEquals(s3,c.getArcs().get(0).destination());
+		
+		
+		c= cheminComplet.extraireChemin(s2, s4);
+		System.out.println("chemin de s2 a s4 apres extraction " + c);
+		assertEquals(2,c.getArcs().size());
+		assertEquals(s2,c.getArcs().get(0).origine());
+		assertEquals(s4,c.getArcs().get(1).destination());
+
+	}
+	
+
+}

2020-2021/tests/TD6/reseauSocialTestV2/FirstTests.java

@@ -0,0 +1,84 @@
+package TD6.reseauSocialTestV2;
+
+import static org.junit.Assert.*;
+
+import java.util.Collection;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import TD6.reseauSocial.core.MemberInterface;
+import TD6.reseauSocial.core.SocialNetworkInterface;
+import TD6.reseauSocial.implementation2020.Member;
+import TD6.reseauSocial.implementation2020.SocialNetWorkImpl;
+
+
+
+
+public class FirstTests {
+
+	
+    //TODO : reference to be modified according to your implementation
+	//Member refers to your implementation of MemberInterface
+	//SocialNetWorkImpl refers to your implementation of SocialNetworkInterface
+    SocialNetworkInterface<Member> iutRS;
+    static String nomGeek = "geek01";
+    
+    @BeforeEach
+    public void setUp(){
+        iutRS = new SocialNetWorkImpl("IUT");
+    }
+    
+    /*
+     * utility functions
+     */
+
+    private Member addMember(String nom, String location, SocialNetworkInterface<Member> nw  ) {
+    	Member m = new Member(nom);
+    	m.setLocation(location);
+        nw.addMember(m);
+        return m;
+	}
+   
+
+    @Test
+    public void testInit() {
+        assertTrue(iutRS != null);
+    }
+
+    
+    
+    /*
+        Serie of simple tests
+     */
+
+
+    @Test
+    public void testAddAndGetMemberSimple() {
+    	String location = "Nice";
+        MemberInterface mGeek01 = addMember(nomGeek, location, iutRS);
+        assertEquals(nomGeek, mGeek01.getName());
+        assertEquals(location, mGeek01.getLocation());
+        assertEquals(mGeek01,iutRS.getMember(nomGeek));
+        
+    }
+    @Test
+    public void testAddAndGetTwoMembers() {
+        MemberInterface mGeek01 = addMember(nomGeek, "Nice", iutRS);
+        MemberInterface mGeek02 = addMember("ivana","Toulon", iutRS);
+        assertEquals(nomGeek, mGeek01.getName());
+        assertEquals("ivana", mGeek02.getName());
+        assertEquals(mGeek01,iutRS.getMember(nomGeek));
+        assertEquals(mGeek02,iutRS.getMember("ivana"));
+    }
+
+    @Test
+    public void testGetMembers() {
+    	 MemberInterface mGeek01 = addMember("geek01", "Nice", iutRS);
+         MemberInterface mGeek02 = addMember("ivana","Toulon", iutRS);
+        Collection<? extends MemberInterface> membres = iutRS.getMembers();
+        assertEquals("taille du reseau est bien de 2 membres", 2,membres.size());
+        assertTrue(membres.contains(mGeek01));
+        assertTrue(membres.contains(mGeek02));
+    }
+}

2020-2021/tests/TD6/reseauSocialTestV2/SecondTests.java

@@ -0,0 +1,155 @@
+package TD6.reseauSocialTestV2;
+
+
+
+import java.util.Set;
+
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import TD6.reseauSocial.core.SocialNetworkInterface;
+import TD6.reseauSocial.core.Strength;
+import TD6.reseauSocial.implementation2020.Member;
+import TD6.reseauSocial.implementation2020.SocialNetWorkImpl;
+
+
+
+public class SecondTests {
+
+	
+    //For Students => TODO : reference to be modified according to your implementation
+	//Member refers to your implementation of MemberInterface
+	//SocialNetWorkImpl refers to your implementation of SocialNetworkInterface
+    SocialNetworkInterface<Member> iutRS;
+
+    @BeforeEach
+    public void setUp() {
+        iutRS = new SocialNetWorkImpl("IUT");
+    }
+    
+    
+    Member asterix;
+    Member falbala ;
+    Member obelix ;
+    Member panoramix ;
+    Member abraracourcix ;
+    
+    
+    /*
+     * utility functions
+     */
+    
+    private void initGaulois(SocialNetworkInterface<Member> iutRS) {
+     String location = "Armorique";
+     asterix = addMember("Asterix",location,iutRS);
+     falbala = addMember("Falbala",location,iutRS);
+     obelix = addMember("Obelix",location,iutRS);
+     panoramix =addMember("Panoramix",location,iutRS);
+     abraracourcix = addMember("Abraracourcix",location,iutRS);
+    }
+    
+    private Member addMember(String nom, String location, SocialNetworkInterface<Member> nw  ) {
+    	Member m = new Member(nom);
+    	m.setLocation(location);
+        nw.addMember(m);
+        return m;
+	}
+
+
+    //------------ Construction des relations ------- //
+
+    private void buildAsterixNetwork() {
+    	initGaulois(iutRS);
+
+        iutRS.relate(Strength.STRONG, asterix, obelix);
+        iutRS.relate(Strength.HIGH, asterix, panoramix);
+        iutRS.relate(Strength.STRONG, obelix, asterix);
+        iutRS.relate(Strength.HIGH,  obelix, falbala);
+        iutRS.relate(Strength.MEDIUM, obelix, panoramix);
+        iutRS.relate(Strength.LOW, falbala, obelix);
+        iutRS.relate(Strength.LOW, falbala, asterix);
+        iutRS.relate(Strength.LOW, panoramix,abraracourcix);
+    }
+
+      
+
+    // ----------------- Pour compatibilité des codes avec Junit4 sans trop me fatiguer :-) 
+    private static void assertEquals(String commentaire, int valeurAttendue, int valeurObtenue) {
+    	Assertions.assertEquals(valeurAttendue, valeurObtenue, commentaire);
+    }
+    private static void assertTrue(String commentaire, boolean value) {
+    	Assertions.assertTrue(value, commentaire);
+    }
+    
+
+
+    // ---------------- Tests
+
+    @Test
+    public void testInit() {
+        Assertions.assertTrue(iutRS != null);
+    	initGaulois(iutRS);
+    	Assertions.assertTrue(obelix!= null);
+    	Assertions.assertTrue(asterix!= null);
+    }
+
+    @Test
+    public void testRelationsAtRankOne() {
+        buildAsterixNetwork();
+        //tests au rang 1
+        Set<Member> membresAmis = iutRS.relatedToRank(asterix, 1);
+        //System.out.println("Amis de Asterix" + membresAmis);
+        assertEquals("taille des amis d'Asterix au rang 1 : 2 membres", 2, membresAmis.size());
+        assertTrue("Asterix est bien ami d'Obelix", membresAmis.contains(obelix));
+        assertTrue("Asterix est bien ami de Panoramix", membresAmis.contains(panoramix));
+        membresAmis = iutRS.relatedToRank(panoramix, 1);
+        //System.out.println("Amis de Panoramix" + membresAmis);
+        assertEquals("taille des amis de Panoramix au rang 1 : 1 membres", 1, membresAmis.size());
+        membresAmis = iutRS.relatedToRank(falbala, 1);
+        assertEquals("taille des amis de Panoramix au rang 1 : 2 membres", 2, membresAmis.size());
+    }
+
+    @Test
+    public void testRelationsAtRankTwoandMore() {
+        buildAsterixNetwork();
+
+        //tests au rang 2
+        Set< Member> membresAmis = iutRS.relatedToRank(asterix, 2);
+        //System.out.println("Amis de Asterix au rang 2" + membresAmis);
+        assertEquals("taille des amis d'Asterix au rang 2 : 2 membre Falbala et Abraracourcix, les autres le sont deja au rang 1", 2, membresAmis.size());
+        assertTrue("Asterix est bien ami de falbala au rang 2", membresAmis.contains(falbala));
+        membresAmis = iutRS.relatedToRank(panoramix, 2);
+        assertEquals("taille des amis de Panoramix au rang 2 : 0 membres", 0, membresAmis.size());
+        membresAmis = iutRS.relatedToRank(obelix, 2);
+        //System.out.println("Amis de Obelix au rang 2" + membresAmis);
+        assertEquals("taille des amis Obelix au rang 2 : 1 membre", 1, membresAmis.size());
+        membresAmis = iutRS.relatedToRank(falbala, 2);
+        assertEquals("taille des amis Falbala au rang 2 : 1 membre", 1, membresAmis.size());
+        membresAmis = iutRS.relatedToRank(falbala, 3);
+        assertEquals("taille des amis Falbala au rang 3 : 1 membre", 1, membresAmis.size());
+        assertTrue("Abraracourcix est bien ami de falbala au rang 3", membresAmis.contains(abraracourcix));
+
+    }
+
+    @Test
+    public void testDistances() {
+        buildAsterixNetwork();
+
+        //Calcul des distances
+        int distance = iutRS.distance(asterix, obelix);
+        assertEquals("distance entre asterix et obelix", Strength.STRONG.getValue(), distance);
+        distance = iutRS.distance(asterix, falbala);
+        assertEquals("distance entre asterix et falbala", Strength.STRONG.getValue() + Strength.HIGH.getValue(), distance);
+        distance = iutRS.distance(asterix, panoramix);
+        assertEquals("distance entre asterix et Panoramix", Strength.HIGH.getValue(), distance);
+        distance = iutRS.distance(falbala, asterix);
+        assertEquals("distance entre falbala et asterix", Strength.LOW.getValue(), distance);
+        distance = iutRS.distance(falbala, abraracourcix);
+        assertEquals("distance entre falbala et Abraracourcix, passe par Asterix", Strength.LOW.getValue()*2 + Strength.HIGH.getValue(), distance);
+        distance = iutRS.distance(asterix, abraracourcix);
+        assertEquals("distance entre asterix et Abraracourcix", Strength.HIGH.getValue() + Strength.LOW.getValue(), distance);
+    }
+
+}

2020-2021/tests/TD6/reseauSocialTestV2/ThirdTests.java

@@ -0,0 +1,172 @@
+package TD6.reseauSocialTestV2;
+
+import static org.junit.Assert.*;
+import TD6.facebookGhost.FacebookGhostNetwork;
+import TD6.facebookGhost.User;
+
+import java.util.Set;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import TD6.reseauSocial.core.SocialNetworkInterface;
+import TD6.reseauSocial.implementation2020.Member;
+import TD6.reseauSocial.implementation2020.SocialNetWorkImpl;
+import TD6.reseauSocial.implementation2020.Spy;
+
+
+
+public class ThirdTests{
+
+	//TODO : reference to be modified according to your implementation
+	//Member refers to your implementation of MemberInterface
+	//SocialNetWorkImpl refers to your implementation of SocialNetworkInterface
+	SocialNetworkInterface<Member> iutRS;
+
+	//Spy snoop = new Spy();
+
+	FacebookGhostNetwork fg ;
+
+
+
+	//------------ Connexions to FG ------- //
+	private FacebookGhostNetwork getFacebookGhostNetwork() {
+		return  new FacebookGhostNetwork();
+	}
+
+	private void buildGreekmythologieNetwork() {
+		User zeus = fg.addUser("Zeus","le dieu ...","Olympe");
+		User alcmene = fg.addUser("Alcmene","la mere d'hercule");
+		User hercule = fg.addUser("Hercule","le hero");
+		User admete = fg.addUser ("Admete","l'ami","Grece");
+		fg.addUser("Hera","la femme de zeus","Olympe");
+		fg.addFamilyRelation(hercule, zeus);
+		fg.addFamilyRelation(hercule, alcmene);
+		fg.addFriendRelation(hercule,admete);		
+	}
+
+	
+	@BeforeEach
+	public void setUp() {
+		iutRS = new SocialNetWorkImpl("IUT");
+		fg = getFacebookGhostNetwork();
+		buildGreekmythologieNetwork();
+	}
+
+
+	@Test
+	public void testInit() {
+		assertTrue(iutRS != null);	
+		assertTrue(fg.getUser("Zeus") != null);
+	}
+
+
+	@Test
+	public void testConnexionToFg() {
+		Member admeteLocal = iutRS.addMember("Admete", fg);
+		assertEquals("location de Admete",
+				fg.getUser("Admete").getHometown().getName(),
+				admeteLocal.getLocation()
+				);
+	}
+	
+	@Test
+	public void testConnexionToFGInitialisation() {
+		Member admeteLocal = iutRS.addMember("Admete", fg);
+		Set<Member> membresAmis = iutRS.relatedToRank(admeteLocal, 1);
+		assertEquals("taille des amis d'ADMETE au rang 1 : 0 membres", 0, membresAmis.size());
+	}
+
+	
+	
+	@Test
+	public void testAdapter() {
+		Member admeteLocal = iutRS.addMember("Admete", fg);
+		assertEquals("location de Admete",
+				fg.getUser("Admete").getHometown().getName(),
+				admeteLocal.getLocation()
+				);
+		fg.getUser("Admete").setLocation("mer Egee");
+		assertEquals("location de Admete",
+				fg.getUser("Admete").getHometown().getName(),
+				admeteLocal.getLocation()
+				);
+	}
+
+
+
+	@Test
+	public void testConnexionToFGWithlinks() {
+		// Hera (not known as Zeus wife)
+		Member admete = iutRS.addMember("Admete", fg);
+		Member zeus = iutRS.addMember("Zeus", fg);
+		Member hera = iutRS.addMember("Hera", fg);
+		Member hercule = iutRS.addMember("Hercule", fg);
+
+		//Test relations
+		Set<Member> membresAmis = iutRS.relatedToRank(admete, 1);
+		assertEquals("taille des amis de Admete au rang 1 : 1 membre Hercule", 1, membresAmis.size());
+
+		membresAmis = iutRS.relatedToRank(hera, 1);
+		//System.out.println("amis Hera au rang 1" + membresAmis);
+		assertEquals("taille des amis Hera au rang 1 : 1 membres", 0, membresAmis.size());
+
+		membresAmis = iutRS.relatedToRank(hercule, 1);
+		//System.out.println("relations de hercule" + membresAmis);
+		assertEquals("taille des amis d'Hercule au rang 1 : 2 membres Admete et Zeus: ", 2, membresAmis.size());
+		assertTrue("Zeus est bien ami de Hercule au rang 1", membresAmis.contains(zeus));
+		assertTrue("Admete est bien ami de Hercule au rang 1", membresAmis.contains(admete));
+
+		int distance = iutRS.distance(hercule, zeus);
+		assertEquals("distance entre hercule et zeus", 2, distance);
+		distance = iutRS.distance(hercule, admete);
+		assertEquals("distance entre hercule et admete", 3, distance);
+
+		membresAmis = iutRS.relatedToRank(hercule, 2);
+		//System.out.println("amis d'Hercule au rang 2" + membresAmis);
+		assertEquals("taille des amis d'Hercule au rang 2 : 0 membre", 0, membresAmis.size());
+
+
+		membresAmis = iutRS.relatedToRank(admete, 1);
+		//System.out.println("amis d'ADMETE au rang 1" + membresAmis);
+		assertEquals("taille des amis d'ADMETE au rang 1 : 1 membres", 1, membresAmis.size());
+		distance = iutRS.distance(admete, hercule);
+		assertEquals("distance entre hercule et admete", 3, distance);
+	}
+
+
+	//------------ Observations  : Connexions e FG ------- //
+	@Test
+	public void testConnexionToFGAndObserver() {
+		iutRS.addMember("Zeus", fg);
+		Member hera = iutRS.addMember("Hera", fg);
+		Member hercule = iutRS.addMember("Hercule", fg);
+		
+		Set<Member> membresAmis = iutRS.relatedToRank(hercule, 1);
+		assertEquals("taille des amis d'Hercule au rang 1 : 1 membre car seul zeus est connu de nous", 1, membresAmis.size());
+	
+		//si on ajoute un lien dans fg entre Hera et hercule on ne le voit pas.
+		fg.addFamilyRelation("Zeus", "Hera");
+		membresAmis = iutRS.relatedToRank(hercule, 1);
+		assertEquals("taille des amis d'Hercule au rang 1 : 1 membre car one ne voit pas lien avec Hera", 1, membresAmis.size());
+		assertTrue (iutRS.relatedToRank(hera, 1).size()==0);
+		
+		//maintenant si lajout de lien se fait dans fg nous les verrons grace à l'observer
+		//Il faut donc enlever le commentaire ci-dessous
+		//fg.addPropertyChangeListener(iutRS);
+		//fg.addPropertyChangeListener(snoop);
+		//((SocialNetWorkImpl)iutRS).addPropertyChangeListener(snoop);
+		fg.addFamilyRelation("Zeus", "Hera");
+		
+		membresAmis = iutRS.relatedToRank(hera, 1);
+		assertEquals("taille des amis Hera au rang 1 : 1 membres", 1, membresAmis.size());
+		
+
+		//Non demande
+		/*   MemberInterface asterix = iutRS.addMember("Asterix",0,"Asterix, le plus intelligent");
+        fg.addUser("Asterix", "Albert Uderzo, Asterix est le seul anti-heros qui ait jamais autant collectionne les succes et les exploits.");
+        assertEquals("description de Asterix", asterix.getDescription(), fg.getUser("Asterix").myProfil());
+		 */
+
+	}
+}