Attachment #19796 for bug #53058

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 53058
Collapse All | Expand All




            // empty result
            return Lookup.EMPTY.lookup (template);
        }
        return delegate.lookup (template);
    }
    
    public Object lookup(Class clazz) {

            return null;
        }
        
        return 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;
    }

    public org.openide.util.Lookup.Item lookupItem (org.openide.util.Lookup.Template template) {
        if (areSubclassesOfThisClassAlwaysExcluded (template.getType ())) {
            return null;
        
        Class[] arr = classes();
        for (int i = 0; i < arr.length; i++) {
            if (acceptFilter (arr[i], retValue, 2)) {
                return null;
            }
        }
        return delegate.lookupItem (template);
        return retValue;
    }
    
    /** @return true if the instance of class c shall never be returned from this lookup

        } 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);
                }
            }
        }
    }
}




    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 });

        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 ());
    }
}

Return to bug 53058

Lines 53-59 Link Here

(-)src/org/openide/util/lookup/ExcludingLookup.java (-150 / +6 lines)
53	// empty result	53	// empty result
54	return Lookup.EMPTY.lookup (template);	54	return Lookup.EMPTY.lookup (template);
55	}	55	}
56	return new R (delegate.lookup (template));	56	return delegate.lookup (template);
57	}	57	}
58		58
59	public Object lookup(Class clazz) {	59	public Object lookup(Class clazz) {
Lines 61-92 Link Here
61	return null;	61	return null;
62	}	62	}
63		63
64	Object res = delegate.lookup (clazz);	64	return delegate.lookup (clazz);
65	if (res == null) {
66	return null;
67	}
68
69	Class[] arr = classes();
70	for (int i = 0; i < arr.length; i++) {
71	if (arr[i].isInstance (res)) {
72	return null;
73	}
74	}
75	return res;
76	}	65	}
77		66
78	public org.openide.util.Lookup.Item lookupItem (org.openide.util.Lookup.Template template) {	67	public org.openide.util.Lookup.Item lookupItem (org.openide.util.Lookup.Template template) {
79	org.openide.util.Lookup.Item retValue = delegate.lookupItem (template);	68	if (areSubclassesOfThisClassAlwaysExcluded (template.getType ())) {
80	if (retValue == null) return null;	69	return null;
81
82	Class[] arr = classes();
83	for (int i = 0; i < arr.length; i++) {
84	if (acceptFilter (arr[i], retValue, 2)) {
85	return null;
86	}
87	}	70	}
88		71	return delegate.lookupItem (template);
89	return retValue;
90	}	72	}
91		73
92	/** @return true if the instance of class c shall never be returned from this lookup	74	/** @return true if the instance of class c shall never be returned from this lookup
Lines 109-239 Link Here
109	} else {	91	} else {
110	return new Class[] { (Class)classes };	92	return new Class[] { (Class)classes };
111	}	93	}
112	}	94	}
113
114	/** based on type decides whether the class accepts or not anObject
115	*/
116	static boolean acceptFilter (Class filter, Object anObject, int type) {
117	switch (type) {
118	case 0: return filter.isInstance (anObject);
119	case 1: return filter.isAssignableFrom ((Class)anObject);
120	case 2: {
121	Item item = (Item)anObject;
122	return filter.isAssignableFrom (item.getType ());
123	}
124	default: throw new IllegalStateException ("Type: " + type);
125	}
126	}
127
128	/** Filters collection accroding to set of given filters.
129	*/
130	static java.util.Collection filter (Class[] arr, java.util.Collection c, int type) {
131	java.util.Collection ret = null;
132
133	TWICE: for (;;) {
134	Iterator it = c.iterator ();
135	BIG: while (it.hasNext ()) {
136	Object res = it.next ();
137	for (int i = 0; i < arr.length; i++) {
138	if (acceptFilter (arr[i], res, type)) {
139	if (ret == null) {
140	// we need to restart the scanning again
141	// as there is an active filter
142	if (type == 1) {
143	ret = new java.util.HashSet ();
144	} else {
145	ret = new ArrayList (c.size ());
146	}
147	continue TWICE;
148	}
149	continue BIG;
150	}
151	}
152	if (ret != null) {
153	// if we are running the second round from TWICE
154	ret.add (res);
155	}
156	}
157	// ok, processed
158	break TWICE;
159	}
160
161	return ret != null ? ret : c;
162	}
163
164
165	/** Delegating result that filters unwanted items and instances.
166	*/
167	private final class R extends WaitableResult implements LookupListener {
168	private Result result;
169	private Object listeners;
170
171	R (Result delegate) {
172	this.result = delegate;
173	}
174
175	protected void beforeLookup (Template t) {
176	if (result instanceof WaitableResult) {
177	((WaitableResult)result).beforeLookup (t);
178	}
179	}
180
181	public void addLookupListener (LookupListener l) {
182	boolean add;
183	synchronized (this) {
184	listeners = AbstractLookup.modifyListenerList (true, l, listeners);
185	add = listeners != null;
186	}
187	if (add) {
188	result.addLookupListener (this);
189	}
190	}
191
192	public void removeLookupListener (LookupListener l) {
193	boolean remove;
194	synchronized (this) {
195	listeners = AbstractLookup.modifyListenerList (false, l, listeners);
196	remove = listeners == null;
197	}
198	if (remove) {
199	result.removeLookupListener (this);
200	}
201	}
202
203	public java.util.Collection allInstances() {
204	return filter (classes (), result.allInstances (), 0);
205	}
206
207	public Set allClasses () {
208	return (Set)filter (classes (), result.allClasses (), 1);
209	}
210
211	public Collection allItems () {
212	return filter (classes (), result.allItems (), 2);
213	}
214
215	public void resultChanged (org.openide.util.LookupEvent ev) {
216	if (ev.getSource () == result) {
217	LookupListener[] arr;
218	synchronized (this) {
219	if (listeners == null) return;
220
221	if (listeners instanceof LookupListener) {
222	arr = new LookupListener[] { (LookupListener) listeners };
223	} else {
224	ArrayList l = (ArrayList)listeners;
225	arr = (LookupListener[])l.toArray (
226	new LookupListener[l.size ()]
227	);
228	}
229	}
230
231	final LookupListener[] ll = arr;
232	final org.openide.util.LookupEvent newev = new org.openide.util.LookupEvent (this);
233	for (int i = 0; i < ll.length; i++) {
234	ll[i].resultChanged(newev);
235	}
236	}
237	}
238	}
239	}	95	}

Lines 51-63 Link Here

(-)test/unit/src/org/openide/util/lookup/ExcludingLookupTest.java (-8 / +27 lines)
51	public void testFunWithInterfaces () throws Exception {	51	public void testFunWithInterfaces () throws Exception {
52	doBasicFilteringTest (java.io.Serializable.class, Integer.class, 0);	52	doBasicFilteringTest (java.io.Serializable.class, Integer.class, 0);
53	}	53	}
54	public void testFunWithInterfaces2 () throws Exception {
55	doBasicFilteringTest (java.io.Serializable.class, Object.class, 1);
56	}
57
58	public void testIntegersQueriedThruObject () throws Exception {
59	doBasicFilteringTest (Number.class, Object.class, 1);
60	}
61		54
62	private void doBasicFilteringTest (Class theFilter, Class theQuery, int numberOfExcpectedEventsAfterOneChange) throws Exception {	55	private void doBasicFilteringTest (Class theFilter, Class theQuery, int numberOfExcpectedEventsAfterOneChange) throws Exception {
63	Lookup lookup = Lookups.exclude (this.instanceLookup, new Class[] { theFilter });	56	Lookup lookup = Lookups.exclude (this.instanceLookup, new Class[] { theFilter });
Lines 150-154 Link Here
150	assertEquals ("Of course it is not there", null, lookup.lookup (theQuery));	143	assertEquals ("Of course it is not there", null, lookup.lookup (theQuery));
151	assertEquals ("Right # of events", numberOfExcpectedEventsAfterOneChange, ll.getCount ());	144	assertEquals ("Right # of events", numberOfExcpectedEventsAfterOneChange, ll.getCount ());
152	}	145	}
153		146
		147	public void testTheBehaviourAsRequestedByDavidAndDescribedByJesse () throws Exception {
		148	class C implements Runnable, java.io.Serializable {
		149	public void run () {}
		150	}
		151	Object c = new C();
		152	Lookup l1 = Lookups.singleton(c);
		153	Lookup l2 = Lookups.exclude(l1, new Class[] {Runnable.class});
		154	assertNull(l2.lookup(Runnable.class));
		155	assertEquals(c, l2.lookup(java.io.Serializable.class));
		156	}
		157
		158	public void testTheBehaviourAsRequestedByDavidAndDescribedByJesseWithUsageOfResult () throws Exception {
		159	class C implements Runnable, java.io.Serializable {
		160	public void run () {}
		161	}
		162	Object c = new C();
		163	Lookup l1 = Lookups.singleton(c);
		164	Lookup l2 = Lookups.exclude(l1, new Class[] {Runnable.class});
		165
		166	Lookup.Result run = l2.lookup (new Lookup.Template (Runnable.class));
		167	Lookup.Result ser = l2.lookup (new Lookup.Template (java.io.Serializable.class));
		168
		169	assertEquals ("Runnables filtered out", 0, run.allItems ().size ());
		170	assertEquals ("One serialiazble", 1, ser.allItems ().size ());
		171	assertEquals ("And it is c", c, ser.allInstances ().iterator ().next ());
		172	}
154	}	173	}