Index: src/org/openide/util/lookup/ExcludingLookup.java =================================================================== RCS file: /cvs/openide/src/org/openide/util/lookup/ExcludingLookup.java,v retrieving revision 1.1 diff -u -r1.1 ExcludingLookup.java --- src/org/openide/util/lookup/ExcludingLookup.java 14 Jan 2005 13:09:34 -0000 1.1 +++ src/org/openide/util/lookup/ExcludingLookup.java 19 Jan 2005 21:41:33 -0000 @@ -53,7 +53,7 @@ // empty result return Lookup.EMPTY.lookup (template); } - return new R (delegate.lookup (template)); + return delegate.lookup (template); } public Object lookup(Class clazz) { @@ -61,32 +61,14 @@ return null; } - Object res = delegate.lookup (clazz); - if (res == null) { - return null; - } - - Class[] arr = classes(); - for (int i = 0; i < arr.length; i++) { - if (arr[i].isInstance (res)) { - return null; - } - } - return res; + return delegate.lookup (clazz); } public org.openide.util.Lookup.Item lookupItem (org.openide.util.Lookup.Template template) { - org.openide.util.Lookup.Item retValue = delegate.lookupItem (template); - if (retValue == null) return null; - - Class[] arr = classes(); - for (int i = 0; i < arr.length; i++) { - if (acceptFilter (arr[i], retValue, 2)) { - return null; - } + if (areSubclassesOfThisClassAlwaysExcluded (template.getType ())) { + return null; } - - return retValue; + return delegate.lookupItem (template); } /** @return true if the instance of class c shall never be returned from this lookup @@ -109,131 +91,5 @@ } else { return new Class[] { (Class)classes }; } - } - - /** based on type decides whether the class accepts or not anObject - */ - static boolean acceptFilter (Class filter, Object anObject, int type) { - switch (type) { - case 0: return filter.isInstance (anObject); - case 1: return filter.isAssignableFrom ((Class)anObject); - case 2: { - Item item = (Item)anObject; - return filter.isAssignableFrom (item.getType ()); - } - default: throw new IllegalStateException ("Type: " + type); - } - } - - /** Filters collection accroding to set of given filters. - */ - static java.util.Collection filter (Class[] arr, java.util.Collection c, int type) { - java.util.Collection ret = null; - - TWICE: for (;;) { - Iterator it = c.iterator (); - BIG: while (it.hasNext ()) { - Object res = it.next (); - for (int i = 0; i < arr.length; i++) { - if (acceptFilter (arr[i], res, type)) { - if (ret == null) { - // we need to restart the scanning again - // as there is an active filter - if (type == 1) { - ret = new java.util.HashSet (); - } else { - ret = new ArrayList (c.size ()); - } - continue TWICE; - } - continue BIG; - } - } - if (ret != null) { - // if we are running the second round from TWICE - ret.add (res); - } - } - // ok, processed - break TWICE; - } - - return ret != null ? ret : c; - } - - - /** Delegating result that filters unwanted items and instances. - */ - private final class R extends WaitableResult implements LookupListener { - private Result result; - private Object listeners; - - R (Result delegate) { - this.result = delegate; - } - - protected void beforeLookup (Template t) { - if (result instanceof WaitableResult) { - ((WaitableResult)result).beforeLookup (t); - } - } - - public void addLookupListener (LookupListener l) { - boolean add; - synchronized (this) { - listeners = AbstractLookup.modifyListenerList (true, l, listeners); - add = listeners != null; - } - if (add) { - result.addLookupListener (this); - } - } - - public void removeLookupListener (LookupListener l) { - boolean remove; - synchronized (this) { - listeners = AbstractLookup.modifyListenerList (false, l, listeners); - remove = listeners == null; - } - if (remove) { - result.removeLookupListener (this); - } - } - - public java.util.Collection allInstances() { - return filter (classes (), result.allInstances (), 0); - } - - public Set allClasses () { - return (Set)filter (classes (), result.allClasses (), 1); - } - - public Collection allItems () { - return filter (classes (), result.allItems (), 2); - } - - public void resultChanged (org.openide.util.LookupEvent ev) { - if (ev.getSource () == result) { - LookupListener[] arr; - synchronized (this) { - if (listeners == null) return; - - if (listeners instanceof LookupListener) { - arr = new LookupListener[] { (LookupListener) listeners }; - } else { - ArrayList l = (ArrayList)listeners; - arr = (LookupListener[])l.toArray ( - new LookupListener[l.size ()] - ); - } - } - - final LookupListener[] ll = arr; - final org.openide.util.LookupEvent newev = new org.openide.util.LookupEvent (this); - for (int i = 0; i < ll.length; i++) { - ll[i].resultChanged(newev); - } - } - } - } + } } Index: test/unit/src/org/openide/util/lookup/ExcludingLookupTest.java =================================================================== RCS file: /cvs/openide/test/unit/src/org/openide/util/lookup/ExcludingLookupTest.java,v retrieving revision 1.1 diff -u -r1.1 ExcludingLookupTest.java --- test/unit/src/org/openide/util/lookup/ExcludingLookupTest.java 14 Jan 2005 13:09:35 -0000 1.1 +++ test/unit/src/org/openide/util/lookup/ExcludingLookupTest.java 19 Jan 2005 21:41:34 -0000 @@ -51,13 +51,6 @@ public void testFunWithInterfaces () throws Exception { doBasicFilteringTest (java.io.Serializable.class, Integer.class, 0); } - public void testFunWithInterfaces2 () throws Exception { - doBasicFilteringTest (java.io.Serializable.class, Object.class, 1); - } - - public void testIntegersQueriedThruObject () throws Exception { - doBasicFilteringTest (Number.class, Object.class, 1); - } private void doBasicFilteringTest (Class theFilter, Class theQuery, int numberOfExcpectedEventsAfterOneChange) throws Exception { Lookup lookup = Lookups.exclude (this.instanceLookup, new Class[] { theFilter }); @@ -150,5 +143,31 @@ assertEquals ("Of course it is not there", null, lookup.lookup (theQuery)); assertEquals ("Right # of events", numberOfExcpectedEventsAfterOneChange, ll.getCount ()); } - + + public void testTheBehaviourAsRequestedByDavidAndDescribedByJesse () throws Exception { + class C implements Runnable, java.io.Serializable { + public void run () {} + } + Object c = new C(); + Lookup l1 = Lookups.singleton(c); + Lookup l2 = Lookups.exclude(l1, new Class[] {Runnable.class}); + assertNull(l2.lookup(Runnable.class)); + assertEquals(c, l2.lookup(java.io.Serializable.class)); + } + + public void testTheBehaviourAsRequestedByDavidAndDescribedByJesseWithUsageOfResult () throws Exception { + class C implements Runnable, java.io.Serializable { + public void run () {} + } + Object c = new C(); + Lookup l1 = Lookups.singleton(c); + Lookup l2 = Lookups.exclude(l1, new Class[] {Runnable.class}); + + Lookup.Result run = l2.lookup (new Lookup.Template (Runnable.class)); + Lookup.Result ser = l2.lookup (new Lookup.Template (java.io.Serializable.class)); + + assertEquals ("Runnables filtered out", 0, run.allItems ().size ()); + assertEquals ("One serialiazble", 1, ser.allItems ().size ()); + assertEquals ("And it is c", c, ser.allInstances ().iterator ().next ()); + } }