Author: echatellier Date: 2009-07-24 16:50:12 +0200 (Fri, 24 Jul 2009) New Revision: 1668 Modified: trunk/src/main/java/org/nuiton/util/CategorisedListenerSet.java trunk/src/main/java/org/nuiton/util/ListenerSet.java Log: Remove ununed ungeneric code, add comment. Modified: trunk/src/main/java/org/nuiton/util/CategorisedListenerSet.java =================================================================== --- trunk/src/main/java/org/nuiton/util/CategorisedListenerSet.java 2009-07-11 12:07:21 UTC (rev 1667) +++ trunk/src/main/java/org/nuiton/util/CategorisedListenerSet.java 2009-07-24 14:50:12 UTC (rev 1668) @@ -51,14 +51,16 @@ * leur derniers referencements * <p/> * <p> Si les categories sont representees par des Class, alors vous pouvez - * utiliser la hierachie de classe pour creer de facon automatique les pere + * utiliser la hierachie de classe pour creer de facon automatique les peres. + * + * @param <L> listener type * * @see org.nuiton.util.ListenerSet */ -public class CategorisedListenerSet<Listener> { // CategorisedListenerSet +public class CategorisedListenerSet<L> { // CategorisedListenerSet /** to use log facility, just put in your code: log.info(\"...\"); */ - static private Log log = LogFactory.getLog(CategorisedListenerSet.class); + private static Log log = LogFactory.getLog(CategorisedListenerSet.class); /** * permet de remplacer toutes les categories. @@ -71,26 +73,28 @@ * HashMap de ListenerSet, en cle l'objet qui caracterise la categorie * en valeur un ListenerSet */ - protected WeakHashMap<Object, ListenerSet<Listener>> listeners = new WeakHashMap<Object, ListenerSet<Listener>>(); + protected WeakHashMap<Object, ListenerSet<L>> listeners = new WeakHashMap<Object, ListenerSet<L>>(); protected WeakHashMap<Object, Object> categoryParent = new WeakHashMap<Object, Object>(); protected boolean isClassCategory = true; -// protected Class listenerClass = null; /** - * Construit un CategorisedListenerSet qui accepte n'importe quel type - * de listener et dont le isClassCategory est activé + * Empty constructor. */ public CategorisedListenerSet() { + } + + /** + * @param isClassCategory si vrai et que les categorie passé en arguement + * lors de l'ajout sont de type Class alors lors du fire on recherche aussi + * les peres dans la hierarchie d'heritage de la classe (Super class et + * interfaces) + */ + public CategorisedListenerSet(boolean isClassCategory) { + this(); + this.isClassCategory = isClassCategory; + } -// /** -// * Construit un CategorisedListenerSet qui accepte les listeners -// * dont le type est passé en parametre et dont le isClassCategory est activé -// */ -// public CategorisedListenerSet(Class listenerClass){ -// this.listenerClass = listenerClass; -// } - /** * @param listenerClass la classe dont doit heriter les listeners pour * etre accepté lors de l'ajout @@ -98,16 +102,18 @@ * lors de l'ajout sont de type Class alors lors du fire on recherche aussi * les peres dans la hierarchie d'heritage de la classe (Super class et * interfaces) + * + * @deprecated unused same as {@code CategorisedListenerSet(boolean)} */ + @Deprecated public CategorisedListenerSet(Class listenerClass, boolean isClassCategory) { -// this(listenerClass); - this.isClassCategory = isClassCategory; + this(isClassCategory); } - protected void checkCategory(Object category) { if (category == ALL) { - throw new IllegalArgumentException("ALL category can't be use to add listener or add Category"); + throw new IllegalArgumentException( + "ALL category can't be use to add listener or add Category"); } } @@ -132,9 +138,9 @@ * @param category la categorie dans lequel il faut ajouter le listener * @param l le listener a ajouter */ - public void add(Object category, Listener l) { + public void add(Object category, L l) { checkCategory(category); - ListenerSet<Listener> listeners = getListeners(category); + ListenerSet<L> listeners = getListeners(category); listeners.add(l); } @@ -145,8 +151,8 @@ * @param category la categorie dans lequel il faut supprimer le listener * @param l le listener a supprimer */ - public void remove(Object category, Listener l) { - ListenerSet<Listener> listeners = getListeners(category); + public void remove(Object category, L l) { + ListenerSet<L> listeners = getListeners(category); listeners.remove(l); } @@ -158,21 +164,15 @@ * @param methodName le nom de la méthode de la classe listener * @param event l'objet event a passer en paramètre de la methode du * listener + * @throws Exception if event can't be fired */ public void fire(Object category, String methodName, Object event) throws Exception { - if (log != null && log.isTraceEnabled()) { + if (log.isTraceEnabled()) { log.trace("fire category: " + category + " method: " + methodName); } - ListenerSet<Listener> ls = getAllListeners(category); + ListenerSet<L> ls = getAllListeners(category); ls.fire(methodName, event); -/* for(Iterator i=iterator(category); i.hasNext();){ - Object o = i.next(); - Log.logDevFinest("org.nuiton.util.CategorisedListenerSet.fire", "fire on: " + o); - Statement stm = new Statement(o, methodName, new Object[]{event}); - stm.execute(); - } -*/ } /** @@ -182,9 +182,11 @@ * * @param category la categorie a partir duquel il faut lancer l'evenement * @param methodName le nom de la méthode de la classe listener + * + * @throws Exception if event can't be fired */ public void fire(Object category, String methodName) throws Exception { - for (Listener l : getAllListeners(category)) { + for (L l : getAllListeners(category)) { Statement stm = new Statement(l, methodName, null); stm.execute(); } @@ -194,8 +196,11 @@ * Retourne un Iterator sur tous les listeners qu'il faut prevenir si on * souhaite prevenir une certaine categorie. Ceci inclue les ancetre de la * categorie + * + * @param category category to get iterator on + * @return iterator */ - public Iterator<Listener> iterator(Object category) { + public Iterator<L> iterator(Object category) { return getAllListeners(category).iterator(); } @@ -203,10 +208,10 @@ * Retourne un ListenerSet contenant tous les listeners c'est à dire les * listener de la categorie demandé mais aussi les listeners des ancetres */ - protected ListenerSet<Listener> getAllListeners(Object category) { - ListenerSet<Listener> result = new ListenerSet<Listener>(); + protected ListenerSet<L> getAllListeners(Object category) { + ListenerSet<L> result = new ListenerSet<L>(); if (category == ALL) { - for (ListenerSet<Listener> ls : listeners.values()) { + for (ListenerSet<L> ls : listeners.values()) { result.addAll(ls); } } else { @@ -214,24 +219,25 @@ while (parentCategory != null) { result.addAll(getListeners(parentCategory)); if (isClassCategory && parentCategory instanceof Class) { - result.addAll(getListenersClass((Class) parentCategory)); + result.addAll(getListenersClass((Class<?>) parentCategory)); } parentCategory = categoryParent.get(parentCategory); } } - if (log != null && log.isTraceEnabled()) { - log.trace("getAllListeners category: " + category + " result: " + result); + if (log.isTraceEnabled()) { + log.trace("getAllListeners category: " + category + " result: " + + result); } return result; } - protected ListenerSet<Listener> getListenersClass(Class category) { - ListenerSet<Listener> result = new ListenerSet<Listener>(); - Class superClass = category.getSuperclass(); + protected ListenerSet<L> getListenersClass(Class<?> category) { + ListenerSet<L> result = new ListenerSet<L>(); + Class<?> superClass = category.getSuperclass(); if (superClass != null) { result.addAll(getAllListeners(superClass)); } - for (Class c : category.getInterfaces()) { + for (Class<?> c : category.getInterfaces()) { result.addAll(getAllListeners(c)); } return result; @@ -241,19 +247,21 @@ * Retourne un ListenerSet contenant seulement les listener de la categorie * demandé. Si la categorie n'existe pas alors elle est créé. */ - protected ListenerSet<Listener> getListeners(Object category) { - ListenerSet<Listener> result = listeners.get(category); + protected ListenerSet<L> getListeners(Object category) { + ListenerSet<L> result = listeners.get(category); if (result == null) { - listeners.put(category, result = new ListenerSet<Listener>()); + listeners.put(category, result = new ListenerSet<L>()); } if (log != null && log.isTraceEnabled()) { - log.trace("getListeners category: " + category + " result: " + result); + log.trace("getListeners category: " + category + " result: " + + result); } return result; } public String toString() { - return "Listeners Category: " + categoryParent + "\nListener: " + listeners; + return "Listeners Category: " + categoryParent + "\nListener: " + + listeners; } } // CategorisedListenerSet Modified: trunk/src/main/java/org/nuiton/util/ListenerSet.java =================================================================== --- trunk/src/main/java/org/nuiton/util/ListenerSet.java 2009-07-11 12:07:21 UTC (rev 1667) +++ trunk/src/main/java/org/nuiton/util/ListenerSet.java 2009-07-24 14:50:12 UTC (rev 1668) @@ -62,30 +62,16 @@ * Cette deuxième façon de faire est plus sûr car elle n'utilise pas * l'introspection et donc une vérification est faite sur le nom de la méthode * à appeler à la compilation, mais elle est plus verbeuse à écrire. + * + * @param <L> listeners type * * @see org.nuiton.util.CategorisedListenerSet */ -public class ListenerSet<Listener> implements Iterable<Listener> { // ListenerSet +public class ListenerSet<L> implements Iterable<L> { // ListenerSet - /** DOCUMENTME Description of the Field DOCUMENTME Description of the Field DOCUMENTME Description of the Field */ -// protected Class<T> listenerClass = null; - /** DOCUMENTME Description of the Field */ - protected HashSet<Reference<Listener>> listeners = new HashSet<Reference<Listener>>(); + /** Listeners reference set. */ + protected HashSet<Reference<L>> listeners = new HashSet<Reference<L>>(); - /** DOCUMENTME Constructor for the ListenerSet object */ - public ListenerSet() { - } - -// /** -// * Constructeur permettant de passer une classe que devra s'attisfaire les -// * listener que l'on souhaite ajouter -// * -// * @param listenerClass DOCUMENTME Description of the Parameter -// */ -// public ListenerSet(Class<T> listenerClass) { -// this.listenerClass = listenerClass; -// } - public int size() { return listeners.size(); } @@ -97,18 +83,13 @@ * si l'objet n'est pas du type passé en argument du constructeur * une IllegalArgumentException est levée. */ - public void add(Listener l) { + public void add(L l) { if (l == null) { return; } -// if (listenerClass == null || listenerClass.isInstance(l)) { - TransparenteWeakReference<Listener> ref = new TransparenteWeakReference<Listener>(l); + + TransparenteWeakReference<L> ref = new TransparenteWeakReference<L>(l); listeners.add(ref); -// } else { -// throw new IllegalArgumentException("Listener object (" -// + l.getClass().getName() + ") is not compatible with class: " -// + listenerClass.getName()); -// } } /** @@ -116,15 +97,8 @@ * * @param ls The feature to be added to the All attribute */ - public void addAll(ListenerSet<Listener> ls) { -// if (listenerClass == null || (ls.listenerClass != null && -// listenerClass.isAssignableFrom(ls.listenDOCUMENTME Description of the ExceptionerClass))) { + public void addAll(ListenerSet<L> ls) { listeners.addAll(ls.listeners); -// } else { -// throw new IllegalArgumentException("Listener object (" -// + ls.listenerClass + ") is not compatible with : " -// + listenerClass); -// } } /** @@ -137,55 +111,52 @@ * @throws Exception si un des listeners leve une exception lors de l'appel */ public void fire(String methodName, Object event) throws Exception { - for (Iterator i = iterator(); i.hasNext();) { - Object o = i.next(); - Statement stm = new Statement(o, methodName, new Object[]{event}); + for (Iterator<L> i = iterator(); i.hasNext();) { + L o = i.next(); + Statement stm = new Statement(o, methodName, new Object[] { event }); stm.execute(); } } /** - * Appel la méthode du listener sans argument + * Appele la méthode du listener sans argument. + * * Cette méthode echoue si la methode ou l'objet contenant la methode a - * appeler n'est pas public + * appeler n'est pas public. * * @param methodName le nom de la methode a appeler * @throws Exception si un des listeners leve une exception lors de l'appel */ public void fire(String methodName) throws Exception { - for (Iterator i = iterator(); i.hasNext();) { - Object o = i.next(); + for (Iterator<L> i = iterator(); i.hasNext();) { + L o = i.next(); Statement stm = new Statement(o, methodName, null); stm.execute(); } } /** - * DOCUMENTME Method + * Get iterator on listener list. * - * @return DOCUMENTME Description of the Return Value + * @return iterator on listener list. */ - public Iterator<Listener> iterator() { - return new ReferenceIterator<Listener>(listeners.iterator()); + public Iterator<L> iterator() { + return new ReferenceIterator<L>(listeners.iterator()); } /** - * DOCUMENTME Method + * Remove listener. * - * @param l DOCUMENTME Description of the Parameter + * @param l listener to remove */ - public void remove(Listener l) { - TransparenteWeakReference<Listener> ref = new TransparenteWeakReference<Listener>(l); + public void remove(L l) { + TransparenteWeakReference<L> ref = new TransparenteWeakReference<L>(l); listeners.remove(ref); } - /** - * DOCUMENTME Method - * - * @return DOCUMENTME Description of the Return Value - */ + @Override public String toString() { - return "" + listeners; + return listeners.toString(); } /** Iterator qui supprime les references vides lors du parcours */ @@ -246,4 +217,3 @@ } } // ListenerSet -