Bonjour à tous,

J'ai un problème en java que je n'arrive pas à résoudre.
Je vous avertis d'entrée, je viens du "monde C++", et je suppose que si je n'arrive pas à faire ce que je veux en java, c'est que j'essaye de calquer des habitudes C++iennes

Alors voilà, je fais actuellement parti d'un projet de recherche mettant au point un compilateur pour un langage dont les types sont composés.

Un type effectif du langage est composé de l'intersection de 3 grandes classes de type :
Type structurel - Vector4, Integer, Float, ...
Type sémantique - Color, Normal, ...
Type d'utilisation - Fragment ou Vertex

J'ai donc le code suivant :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
// Interface pour les types sémantiques
public interface SemanticType
{
}
 
// Exemple de type sémantique
public class Color implements SemanticType
{
}
 
// Interface pour les types d'utilisation
public interface UseType
{
}
 
// Exemple de type d'utilisation
public class Fragment implements UseType
{
}
 
// Exemple de type d'utilisation
public class Vertex implements UseType
{
}
 
// Interface pour les types structurels
public interface StructuralType
{
}
 
// Exemple de type structurel
public class Vector4 implements StructuralType
{
}
 
// Type effectif
public class Type <Semantic extends SemanticType, Use extends UseType, Structure extends StructuralType>
{
  Semantic  semantic_;
  Use       use_;
  Structure structure_;
}
Je peux donc créer des variables avec des types effectifs de cette manière :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
Type<Color,Fragment,Vector4> color1;
Type<Color,Vertex,Vector4>   color2;
Pour le moment rien de bien incroyable.
Le but maintenant est de gérer les casts entre ces types effectifs. Dans la mesure du possible, l'objectif serait d'avoir un système très souple, à savoir :
- Ne pas avoir à maintenir à jour une liste de types existants, l'inférence doit se faire dynamiquement.
- Ne pas disperser la logique de cast en plusieurs endroits, dans l'idéal une méthode par cast pour chaque types différents.

C'est à dire qu'en C++, j'aurais voulu pouvoir faire quelque chose de ce genre :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void cast( Type<Color,Fragment,Vector4> color1, Type<Color,Vertex,Vector4> color2 )
{
  // Gestion du cast
}
 
void cast( Type<Color,Vertex,Vector4> color1, Type<Color,Fragment,Vector4> color2 )
{
  // Gestion du cast
}
 
void cast( Type<Color,Fragment,Vector3> color1, Type<Color,Vertex,Vector4> color2 )
{
  // Gestion du cast
}
 
...
Cela semble être impossible en java.
Erreur de 'name clash'.
De ce que j'ai compris, java perd les informations sur les types génériques dès la compilation terminée (généricit par 'type erasure'). La signature de mes fonctions deviendrait donc :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void cast( Type color1, Type color2 )
{
  // Gestion du cast
}
 
void cast( Type color1, Type color2 )
{
  // Gestion du cast
}
 
void cast( Type color1, Type color2 )
{
  // Gestion du cast
}
 
...
Ce qui bien sur n'est pas possible.


Je voudrais donc savoir s'il y avait une solution propre, à ce problème, qui au final peut se résoudre à: faire du polymorphisme sur des types génériques.

Le but étant évidemment d'éviter des constructions de la forme:
- Je met des Object en argument
- Une tonne de "instanceof" dans un gros switch
- je dispatch sur la bonne méthode une fois les types trouvés

Merci à tous ceux qui auront pris le temps de lire ce message