Gestion spacio temporelle
J'ai un problème.
Attribuer 1 place libre à un moment donné.
Ca fait partie d'un projet que je dois rendre au plus tard lundi 07/05
Je pense pas le finir à temps, mais au moins si je pouvais bénéficier de votre aide pour m'aider à avancer.
Je viens tout juste de comprendre l'utilisation du Hashtable (enfin, je crois). Il me faudra sans doute utiliser aussi des Arraylist.
vous pouvez déjà jetter un oeil sur ce que j'ai déjà fait et éventuellement, m'indiquer les choses à modifier (je débute en java, donc c'est pas du code 'propre') et peut-être me proposer quelques méthodes qui me manquent.
Etant à une formation en cours du soir (je bosse la journée) je dispose de peu de loisirs. Donc ça ne va pas être évident de présenter un truc qui fonctionne à peu prêt en si peu de temps.
Merci de votre aide. Au moins sur ce que j'ai déjà écrit :)
En gros :
on dispose de 2 fichiers :
Trains.txt qui contient les données code train, type train :
Code:
1
2
3
4
5
6
| ETR00120045 CORAIL-H667
HGD00150056 CORAIL-727
NJU12340001 TGV-TV56
POI00780012 TGV-A310
KDE00980032 CORAIL-747
... |
ProgrammeCircules qui contient code Circule, heure, minute, ville, codeTrain
Code:
1
2
3
4
5
6
7
8
9
| IT4444 13 10 RENNES ETR00120045
IT0056 15 00 TOULOUSE ETR00120045
IT1919 12 30 STRASBOURG EVE00012345
IT0985 16 15 STRASBOURG EVE00012345
IT3330 15 30 BORDEAUX GFD00150056
IT0411 17 30 BORDEAUX GFD00150056
IT7777 17 10 MARSEILLE RTG78945612
IT0650 18 40 MARSEILLE RTG78945612
etc ... |
...
Des voies :
voie p1, p2, p3 ...
et pour les trains 'lourds', comme le TGV-TV56, des voies distantes
d1, d2, d3 ...
Il faut donc parquer les trains sur les voie libres durant les durées indiquées (arrivée, départ).
Par exemple, ETR00120045 arrive de Rennes à 13h10
et repart pour Toulouse à 15h (les 2 premières lignes du fichier ProgrammeCircule).
Quand c'est un TGV-TV56, le train doit se poser sur un voie distante.
Alors, rapidement, j'ai écrit quelques classes (ci-dessous) mais suis coincé et ne parviens pas encore à attribuer les trains à des voies.
Après, il faudra que je gère l'affichage pour chaque Hall (4 à 6 halls pour chaque voie) des arrivées et départs.
Ca, j'espère pouvoir m'en sortir, mais j'aurais par contre besoin d'aide pour l'attribution de voies en fonction des séjours.
Merci de m'aider.
Voici les fichiers créés :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
| // Initialiser.java
import java.net.*;
import java.io.*;
import java.util.*;
public class Initialiser
{ public static void main (String args[]) throws IOException
{ final int longNumLigne = 4 ; // nombre de caracteres utilises pour
// afficher le numero de ligne
final int nbCarParLigne = 60 ;
String nomfich ;
String ligne ; // ligne courante du fichier texte
char charNumLigne[] = new char[longNumLigne] ; // pour les caracteres
// du numero de ligne
//
// On initialise les trains a partir du fichier
//
nomfich="DonneesProjet/trains.txt";
BufferedReader entree = new BufferedReader (new FileReader (nomfich)) ;
int numLigne = 0 ;
Hashtable lesTrains=new Hashtable;
do
{ /* lecture d'une ligne du fichier */
ligne = entree.readLine() ;
if (ligne == null) break ;
StringTokenizer tokenizer = new StringTokenizer(ligne);
int count = tokenizer.countTokens();
while (tokenizer.hasMoreTokens())
{
// on créer l'train, selon qu'il soit gros (TGV-TV56) ou pas
String code = tokenizer.nextToken();
String type = tokenizer.nextToken();
if (type.equals("TGV-TV56"))
new TrainGros(code,type);
else
new Train(code,type);
}
System.out.println () ;
}
while (ligne != null) ;
entree.close () ;
System.out.println ("*** fin de fichier Trains ***");
//
// On initialise les circulations a partir du fichier
//
nomfich="DonneesProjet/ProgrammeCircules";
entree = new BufferedReader (new FileReader (nomfich)) ;
numLigne = 0 ;
do
{
// lecture et traitement circulation arrivee
ligne = entree.readLine() ;
if (ligne == null) break ;
StringTokenizer tokenizer = new StringTokenizer(ligne);
int count = tokenizer.countTokens();
while (tokenizer.hasMoreTokens())
{
// on creer l' arrivee en fonction des donnees lues
String nomCircule = tokenizer.nextToken();
int heure = tokenizer.nextToken();
int minute = tokenizer.nextToken();
String ville = tokenizer.nextToken();
String codeTrain = tokenizer.nextToken();
new CirculeArrivee(nomCircule,heure,minute,ville,codeTrain);
// lecture et traitement du depart
ligne = entree.readLine() ;
if (ligne == null) break ;
StringTokenizer tokenizer = new StringTokenizer(ligne);
int count = tokenizer.countTokens();
while (tokenizer.hasMoreTokens())
{
// on creer l'arrivee en fonction des donnees lues
String nomCircule = tokenizer.nextToken();
int heure = tokenizer.nextToken();
int minute = tokenizer.nextToken();
String ville = tokenizer.nextToken();
String codeTrain = tokenizer.nextToken();
System.out.println () ;
}
while (ligne != null) ;
entree.close () ;
System.out.println ("*** fin liste fichier circulations ***");
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
| // Train.java
//
// Projet Gare
// Fichier : Train.java
//
import java.util.*;
public class Train {
private String codeTrain;
private String typeTrain;
private static Hashtable lesTrains;
private static Hashtable lesSejours;
private ArrayList lesCircules;
public void Train(String code, String type) {
codeTrain=code;
typeTrain=type;
lesTrains.put(code,this);
}
public void setTrain() {
}
public void getTrain() {
}
public void getCode() {
}
public void getType() {
return this.typeTrain;
}
public void getPlace() {
}
// renvoie l'train en fonction du code
public static Train getRefTrain(String code) {
return (Train)lesTrains.get(code);
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| // TrainGros.java
//
// Projet Gare
// Fichier : TrainGros.java
//
public class TrainGros extends Train {
// la gestion de TGV-TV56 sera différente de celle des trains ordinaires
public void setPlace() {
}
public void getPlace() {
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
| // Circule.java
//
// Projet Gare
// Fichier : Circule.java
/
public class Circule {
private String nomCircule;
private Int heure;
private Int minute;
private Horaire hh;
private String ville;
private String codeTrain;
private Sejour vSejour;
private String message;
public Circule(String Circule,int h,int mn,String v,String train) {
nomCircule=Circule;
heure=h;
minute=mn;
ville=v;
codeTrain=train;
hh=getHoraire(h,mn);
}
public void SetCircule() {
}
public Circule getCircule() {
}
public void setHeure () {
hh=Horaire(this.heure,this.minute);
}
public Horaire getHeure() {
return(this.hh);
}
public void setRetard(int retard) {
message = " mn de retard";
// verifie que le voie permet le retard
// 1. attribuer un autre voie si pas possible
// 2. si pas possible et pas d'autres attribution, retarder le train qui suit
// prevoir repercussion en chaine
}
public String getRetard() {
return message;
}
public void setAnnule() {
message = "Annulé";
// liberer place voie
}
public void getAnnule() {
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| // CirculeArrivee.java
//
// Projet Gare
// Fichier : CirculeArrivee.java
//
public class CirculeArrivee extends Circule {
private String message;
public String getRetard() {
return message;
}
public void setAnnule() {
message = "Annulé";
// liberer place voie
}
public void getAnnule() {
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| // CirculeDepart.java
//
// Projet Gare
// Fichier : CirculeDepart.java
//
public class CirculeDepart extends Circule {
private String message;
public String getRetard() {
return message;
}
public void setAnnule() {
message = "Annulé";
// liberer place voie
}
public void getAnnule() {
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
| // Paking.java
//
// Projet Gare
// Fichier : voie.java
//
public class voie {
private Object nomvoie;
public Sejour pSejour;
} |
Code:
1
2
3
4
| // voieDistant.java
public class voieDistant extends Pointvoie {
private Int pPorte;
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| // Sejour.java
//
// Projet Gare
// Fichier : Sejour.java
//
public class Sejour {
private Train train;
private Circule Arrivee;
private Circule Depart;
private TrancheHoraire horaire;
private Pointvoie svoie;
public Sejour() {
}
//
public setHeureSejour() {
}
// parcours les voies jusqu'à en trouver un libre
public Parkin trouvevoie() {
new TrancheHoraire t1(this.heureArrivee, this.heureDepart)
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| // Horaire.java
package gare;
public class Horaire implements Comparable, Cloneable{
private int heures,minutes;
public Horaire() {
heures=0;
minutes=0;
}
public Horaire(int h,int m) {
heures=h;
minutes=m;
}
public Horaire(int m){
m=m%1440;
heures=m/60;minutes=m%60;
}
public int horaireEnMinutes(){
return heures*60+minutes;
}
public Horaire ajout(Duree d){
int h=horaireEnMinutes()+d.dureeEnMinutes();
if(h>=1440)
h=h%1440;
return new Horaire(horaireEnMinutes()+d.dureeEnMinutes());
}
public Horaire retrait(Duree d){
int h=horaireEnMinutes()-d.dureeEnMinutes();
while(h<0)
h=h+1440;
return new Horaire(h);
}
public Duree retrait(Horaire h){
int m=this.horaireEnMinutes()-h.horaireEnMinutes();
if(m<0) m=-m;
return new Duree(m);
}
public String toString(){
String tHeures=heures +" h ";
String tMinutes=((minutes<10)?"0":"")+minutes;
String info=tHeures+tMinutes;
return info;
}
public void afficher(){
System.out.println(toString());
}
public int compareTo(Object o){
Horaire h=(Horaire) o;
return horaireEnMinutes()-h.horaireEnMinutes();
}
public Object clone()throws CloneNotSupportedException{
Horaire h=(Horaire)super.clone();
return h;
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
| // TrancheHoraire.java
package gare;
public class TrancheHoraire {
private Horaire debut;
private Horaire fin;
public TrancheHoraire(Horaire d, Horaire f) {
debut=d;fin =f;
}
// accesseurs
public Horaire getDebutTrancheHoraire(){
return debut;
}
public Horaire getFinTrancheHoraire(){
return fin;
}
// méthodes
/**
* indique si l'horaire h est dans la tranche horaire, objet receveur
* @param h:Horaire
* @return boolean
*/
public boolean contient(Horaire h){
return h.compareTo(debut)>=0 && h.compareTo(fin)<=0 ;
}
/**
* indique si la tranche horaire objet receveur est contenue dans la tranche paramètre
* @param t:TrancheHoraire
* @return boolean
*/
public boolean dansTrancheHoraire(TrancheHoraire t){
return (debut.compareTo(t.debut)>=0)&&(fin.compareTo(t.fin)<=0);
}
public boolean equals(Object o){
TrancheHoraire t=(TrancheHoraire)o;
return debut.equals(t.debut)&& fin.equals(t.fin);
}
public boolean contient (TrancheHoraire t){
return t.dansTrancheHoraire(this);
}
// calcule le nombre de partitions induites par la tranche t dans la tranche this
// A n'utiliser que si this contient t
public int nombrePartitions(TrancheHoraire t){
int n=0;
if(this.equals(t))
n=0;
else if((debut.equals(t.debut))||(fin.equals(t.fin)))
n=1;
else
n=2;
return n;
}
public boolean dansTrancheHoraire(Horaire d,Horaire f){
return (debut.compareTo(d)>=0)&&(fin.compareTo(f)<=0);
}
public TrancheHoraire intersection(TrancheHoraire t){
if(this.dansTrancheHoraire(t)){
return new TrancheHoraire(debut,fin);
}
else
if(t.dansTrancheHoraire(this))
return new TrancheHoraire(t.debut,t.fin);
else
if(!this.contient(t.debut)&&!this.contient(t.fin)){
return null;
}
else if(this.contient(t.debut)){
return new TrancheHoraire(t.debut,fin);
}
else return new TrancheHoraire(debut,t.fin);
}
public Duree getDuree(){
return fin.retrait(debut);
}
public String toString(){
String info=" début:"+debut.toString()+ " fin:"+fin.toString();
return info;
}
} |
