Problème de générique

Version imprimable

Bonjour, j'essaie de faire un petit dispatcher d’événements hors liste d'affichage qui fonctionne un peu de la même manière et je me heurte aux génériques qui ne veulent rien savoir (ligne 32).

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
 
public class EventDispatcher
{
	private LinkedHashMap<EventType<? extends Event>, ArrayList<EventHandler<? extends Event>>> _listeners;
 
 
	public EventDispatcher()
	{
		_listeners = new LinkedHashMap<EventType<? extends Event>, ArrayList<EventHandler<? extends Event>>>(1, 1);
	}
 
 
	public <T extends Event> void addEventListener(EventType<T> type, EventHandler<T> listener)
	{
		ArrayList<EventHandler<? extends Event>> l = _listeners.get(type);
 
		if (l == null)
		{
			l = new ArrayList<EventHandler<? extends Event>>(1);
			_listeners.put(type, l);
		}
 
		if (!l.contains(listener)) l.add(listener);
	}
 
 
	public void dispatchEvent(Event event)
	{
		EventType<? extends Event> t = event.getEventType();
		ArrayList<EventHandler<? extends Event>> l = _listeners.get(t);
		if (l == null) return;
		for (EventHandler<? extends Event> i : l) i.handle(event); // capture<? extends Event> cannot be applied to (Event)
	}
}

Où sont mes erreurs ?

C'est normal, ? extends Event veux dire "une sous classe bien précise de Event, mais que j'ignore". Donc tu essaie d'appeler une méthode qui attends une sous classe bien précise, en lui passant une sous class quelconque, tu as toutes les chance que ce ne soit pas la bonne classe et donc le compilateur refuse à raison.

Bon, ça c'est quand on isole la ligne en question. Quand on regarde le code de la méthode, je suppose que tu part du principe que le "? extends Event" est le même lors de EventType<? extends Event>, de ArrayList<EventHandler<? extends Event>> et de EventHandler<? extends Event>. Le deux problèmes que tu as, c'est que tu passe par plusieurs méthodes retournant des ? qui ne sont pas liés entre eux pour le compilateur. Et que même si tu voulais les lier (en typant la méthode dispatchEvent), ta map, elle, n'empêche nullement de stocker une ArrayList<MouseEvent> avec une clé EventType<KeyEvent>.

Pour faire propre, il faut typer un peu plus. Mais tu n'y coupera pas, il y aura des instructions disant au compilateur que tu fais pas propre mais que tu sais ce que tu fais.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public <T extends Event> void dispatchEvent(T event) { EventType<T> t = event.getEventType(); ArrayList<EventHandler<T>> l = getListeners(t); if (l == null) return; for (EventHandler<T> i : l) i.handle(event); } @SuppressWarnings("unchecked") public <T extends Event> void getListeners(EventType<T> type){ return (ArrayList<EventHandler<T>>) _listeners.get(type); }

19/01/2016, 21h03
BBric

J'ai également des avertissements avec ta technique, mais ça m'a amené sur la piste de l'uniformité du typage. Ma map n'était pas assez restrictive mais son accès était limité par une méthode qui elle l'était, je pensais que c'était suffisant mais il semble que non.
Donc le mieux que j'ai trouvé c'est de typer la classe elle même afin d'éviter les passages de 'T' à '? extends' et inversement, car ça donne des avertissements incompréhensibles, et si une sous-classe a besoin de plusieurs types d'événements il lui suffit d'utiliser le sous-type Event. A priori je ne vois pas de limitation évidente à ce fonctionnement.
Merci pour ton aide. :)