Attachment #114327 for bug #206556

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 206556
Collapse All | Expand All

Lines 179-185 Link Here

(-)a/hudson/nbproject/project.xml (-1 / +1 lines)
179	<build-prerequisite/>	179	<build-prerequisite/>
180	<compile-dependency/>	180	<compile-dependency/>
181	<run-dependency>	181	<run-dependency>
182	<specification-version>7.9</specification-version>	182	<specification-version>7.27</specification-version>
183	</run-dependency>	183	</run-dependency>
184	</dependency>	184	</dependency>
185	<dependency>	185	<dependency>





import java.io.CharConversionException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import javax.swing.Action;
import org.netbeans.modules.hudson.api.HudsonJob;

        }
        return Children.create(new ChildFactory<Object>() {
            final Object WORKSPACE = new Object();
            LinkedList<HudsonJobBuild> builds;
            protected @Override boolean createKeys(List<Object> toPopulate) {
                // XXX would be nicer to avoid adding this in case there is no remote workspace...
                toPopulate.add(WORKSPACE);
                for (HudsonJobBuild b : job.getBuilds()) {
                    // XXX would be nicer to avoid adding this in case there is no remote workspace...
                    toPopulate.add(WORKSPACE);
                    builds = new LinkedList<HudsonJobBuild>(job.getBuilds());
                    return false;
                } else if (builds.isEmpty()) {
                    return true;
                } else {
                    // Processing one build at a time, make sure its result is known (blocking call).
                    HudsonJobBuild b = builds.removeFirst();
                    b.getResult();
                    toPopulate.add(b);
                    return false;
                }
                return true;
            }
            protected @Override Node createNodeForKey(Object key) {
                if (key == WORKSPACE) {

Lines 349-355 Link Here

(-)a/maven/nbproject/project.xml (-1 / +1 lines)
349	<build-prerequisite/>	349	<build-prerequisite/>
350	<compile-dependency/>	350	<compile-dependency/>
351	<run-dependency>	351	<run-dependency>
352	<specification-version>7.5</specification-version>	352	<specification-version>7.27</specification-version>
353	</run-dependency>	353	</run-dependency>
354	</dependency>	354	</dependency>
355	<dependency>	355	<dependency>




         
        @Override
        protected boolean createKeys(final List<Wrapper> modules) {
            for (String module : project.getOriginalMavenProject().getModules()) {
            int alreadyAdded = modules.size();
            if (alreadyAdded >= all.size()) {
                return true;
            }
            String module = all.get(alreadyAdded);
            File base = project.getOriginalMavenProject().getBasedir();
                File projDir = FileUtil.normalizeFile(new File(base, module));
                FileObject fo = FileUtil.toFileObject(projDir);

                            wr.isAggregator = NbMavenProject.TYPE_POM.equals(mp.getPackaging()) && !mp.getModules().isEmpty();
                            wr.provider = prj.getLookup().lookup(LogicalViewProvider.class);
                            modules.add(wr);
                            return false;
                        }
                    } catch (IllegalArgumentException ex) {
                        ex.printStackTrace();//TODO log ?

                } else {
                    //TODO broken module reference.. show as such..
                }
            }
            return true;
        }

        @Override
        protected Node createNodeForKey(Wrapper wr) {
            if (wr.proj == null) {
                return null;
            }
             return new ProjectFilterNode(project, wr.proj, wr.provider.createLogicalView(), wr.isAggregator);
        }
        




<apidef name="nodes">Nodes API</apidef>
</apidefs>
<changes>
    <change id="ChildFactory.incremental">
        <api name="nodes"/>
        <summary><code>ChildFactory.createKeys</code> better supports incremental display</summary>
        <version major="7" minor="27"/>
        <date year="2012" month="1" day="3"/>
        <author login="jglick"/>
        <compatibility modification="yes" semantic="compatible">
            <p>
                Existing factories which returned false from <code>createKeys</code>
                may continue to do so with the same behavior, but should consider
                just producing all keys within the body of the loop instead.
            </p>
        </compatibility>
        <description>
            <p>
                An implementation of <code>ChildFactory.createKeys</code> may now
                use <code>List.add</code> a number of times and return true at the
                end, while still displaying keys incrementally.
            </p>
        </description>
        <class package="org.openide.nodes" name="ChildFactory"/>
        <issue number="206556"/>
    </change>
    <change id="NodeOperation.showCustomEditorDialog">
        <api name="nodes"/>
        <summary>A way to show a custom editor dialog for a property</summary>

Lines 2-6 Link Here

(-)a/openide.nodes/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.openide.nodes	2	OpenIDE-Module: org.openide.nodes
3	OpenIDE-Module-Localizing-Bundle: org/openide/nodes/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/openide/nodes/Bundle.properties
4	AutoUpdate-Essential-Module: true	4	AutoUpdate-Essential-Module: true
5	OpenIDE-Module-Specification-Version: 7.26	5	OpenIDE-Module-Specification-Version: 7.27
6		6




    volatile boolean cancelled = false;
    volatile boolean notified;
    private final Object notifyLock = new Object();
    private static final class Stop extends RuntimeException {}
    public void run() {
        boolean fail = cancelled || Thread.interrupted();
        logger.log (Level.FINE, "Running background children creation on " + //NOI18N

            setKeys (Collections.<T>emptyList());
            return;
        }
        List <T> keys = new LinkedList <T> () {
            @Override public boolean add(T e) {
                if (cancelled || Thread.interrupted()) {
                    throw new Stop();
                }
                super.add(e);
                LinkedList<Object> newKeys = new LinkedList<Object>(this);
                Node n = factory.getWaitNode();
                if (n != null) {
                    newKeys.add(n);
                }
                setKeys(newKeys);
                return true;
            }
        };
        boolean done;
        do {
            synchronized (notifyLock) {

                setKeys (Collections.<T>emptyList());
                return;
            }
            try {
                done = factory.createKeys(keys);
            } catch (Stop stop) {
                done = true;
            }
            if (cancelled || Thread.interrupted()) {
                setKeys (Collections.<T>emptyList());
                return;
            }
            LinkedList<Object> newKeys = new LinkedList<Object>(keys);
            if (!done) {
                Node n = factory.getWaitNode();
                if (n != null) {
                    newKeys.add(n);
                }
            }
            setKeys (newKeys);
        } while (!done && !Thread.interrupted() && !cancelled);
        initialized = done;
    }

Lines 131-137 Link Here

(-)a/openide.nodes/src/org/openide/nodes/ChildFactory.java (-1 / +5 lines)
131	* Children.create() with the <code>asynchronous</code> parameter	131	* Children.create() with the <code>asynchronous</code> parameter
132	* set to true. If not, then no guarantees are made as to what	132	* set to true. If not, then no guarantees are made as to what
133	* the calling thread is.	133	* the calling thread is.
134	*	134	* <p>Returning false is tricky since there is no way to tell whether
		135	* the loop has been restarted except by examining what is already in
		136	* the list. As of 7.27 it is generally unnecessary since calls to
		137	* {@link List#add(Object)} will immediately display the new element
		138	* as well as checking for interruption.
135	* @param toPopulate A list to add key objects to	139	* @param toPopulate A list to add key objects to
136	* @return true if the list of keys has been completely populated,	140	* @return true if the list of keys has been completely populated,
137	* false if the list has only been partially populated and	141	* false if the list has only been partially populated and

Lines 190-196 Link Here

(-)a/projectui/nbproject/project.xml (-1 / +1 lines)
190	<build-prerequisite/>	190	<build-prerequisite/>
191	<compile-dependency/>	191	<compile-dependency/>
192	<run-dependency>	192	<run-dependency>
193	<specification-version>6.2</specification-version>	193	<specification-version>7.27</specification-version>
194	</run-dependency>	194	</run-dependency>
195	</dependency>	195	</dependency>
196	<dependency>	196	<dependency>





    // private static final Comparator NATURAL_NAME_SORT = Collator.getInstance();

    private enum Visibility {HIDE, LEAF, CATEGORY}
    private final class TemplateKey {
        final DataObject d;
        final boolean leaf;
        TemplateKey(DataObject d, boolean leaf) {
            this.d = d;
            this.leaf = leaf;
        }
        @Override public boolean equals(Object o) {
            if (!(o instanceof TemplateKey)) {
                return false;
            }
            return d == ((TemplateKey) o).d && leaf == ((TemplateKey) o).leaf;
        }
        @Override public int hashCode() {
            return d.hashCode();

        }

        @Override protected boolean createKeys(List<TemplateKey> keys) {
            for (DataObject d : folder.getChildren()) {
                if (isFolderOfTemplates(d)) {
                    boolean leaf = true;
                    for (DataObject child : ((DataFolder) d).getChildren()) {
                        if (isFolderOfTemplates(child)) {
                            leaf = false;
                            break;
                        }
                    }
                    keys.add(new TemplateKey(d, leaf));
                }
            }
            return true;
            Visibility v;
            if (isFolderOfTemplates(d)) {
                v = Visibility.LEAF;
                for (DataObject child : ((DataFolder) d).getChildren()) {
                    if (isFolderOfTemplates(child)) {
                        v = Visibility.CATEGORY;
                        break;
                    }
                }
            } else {
                v = Visibility.HIDE;
            }
            keys.add(new TemplateKey(d, v));
            return false;
        }
        
        @Override protected Node createNodeForKey(TemplateKey k) {
            return new FilterNode(k.d.getNodeDelegate(), k.leaf ? Children.LEAF : Children.create(new TemplateChildren((DataFolder) k.d), true));
            case CATEGORY:
                return new FilterNode(k.d.getNodeDelegate(), Children.create(new TemplateChildren((DataFolder) k.d), true));
            case LEAF:
                return new FilterNode(k.d.getNodeDelegate(), Children.LEAF);
            default:
                return null;
            }
        }
        
        @Override public void actionPerformed (ActionEvent event) {

        
    }
    
    private final class FileChildren extends ChildFactory<DataObject> {
        final DataObject d;
        final boolean visible;
        FileKey(DataObject d, boolean visible) {
            this.d = d;
            this.visible = visible;
        }
        @Override public boolean equals(Object o) {
            if (!(o instanceof FileKey)) {
                return false;
            }
            return d == ((FileKey) o).d && visible == ((FileKey) o).visible;
        }
        @Override public int hashCode() {
            return d.hashCode();
        }
    }
    private final class FileChildren extends ChildFactory<FileKey> {
        
        private DataFolder root;
                

            assert this.root != null : "Root can not be null";  //NOI18N
        }
        
        @Override protected boolean createKeys(List<DataObject> keys) {
            for (DataObject dobj : root.getChildren()) {
                if (isTemplate(dobj) && OpenProjectList.isRecommended(projectRecommendedTypes, dobj.getPrimaryFile())) {
                    if (dobj instanceof DataShadow) {
                        dobj = ((DataShadow) dobj).getOriginal();
                    }
                    keys.add(dobj);
                }
            }
            return true;
            if (isTemplate(dobj) && OpenProjectList.isRecommended(projectRecommendedTypes, dobj.getPrimaryFile())) {
                if (dobj instanceof DataShadow) {
                    dobj = ((DataShadow) dobj).getOriginal();
                }
                keys.add(new FileKey(dobj, true));
            } else {
                keys.add(new FileKey(dobj, false));
            }
            return false;
        }

        @Override protected Node createNodeForKey(DataObject d) {
            return new FilterNode(d.getNodeDelegate(), Children.LEAF);
        }
        
    }

Return to bug 206556

Lines 269-287 Link Here

(-)a/projectui/src/org/netbeans/modules/project/ui/TemplateChooserPanelGUI.java (-67 / +29 lines)
269		269
270	// private static final Comparator NATURAL_NAME_SORT = Collator.getInstance();	270	// private static final Comparator NATURAL_NAME_SORT = Collator.getInstance();
271		271
272	private enum Visibility {HIDE, LEAF, CATEGORY}
273	private final class TemplateKey {	272	private final class TemplateKey {
274	final DataObject d;	273	final DataObject d;
275	final Visibility visibility;	274	final boolean leaf;
276	TemplateKey(DataObject d, Visibility visibility) {	275	TemplateKey(DataObject d, boolean leaf) {
277	this.d = d;	276	this.d = d;
278	this.visibility = visibility;	277	this.leaf = leaf;
279	}	278	}
280	@Override public boolean equals(Object o) {	279	@Override public boolean equals(Object o) {
281	if (!(o instanceof TemplateKey)) {	280	if (!(o instanceof TemplateKey)) {
282	return false;	281	return false;
283	}	282	}
284	return d == ((TemplateKey) o).d && visibility == ((TemplateKey) o).visibility;	283	return d == ((TemplateKey) o).d && leaf == ((TemplateKey) o).leaf;
285	}	284	}
286	@Override public int hashCode() {	285	@Override public int hashCode() {
287	return d.hashCode();	286	return d.hashCode();
Lines 304-340 Link Here
304	}	303	}
305		304
306	@Override protected boolean createKeys(List<TemplateKey> keys) {	305	@Override protected boolean createKeys(List<TemplateKey> keys) {
307	DataObject[] kids = folder.getChildren();	306	for (DataObject d : folder.getChildren()) {
308	int alreadyAdded = keys.size();	307	if (isFolderOfTemplates(d)) {
309	if (alreadyAdded >= kids.length) {	308	boolean leaf = true;
310	return true;	309	for (DataObject child : ((DataFolder) d).getChildren()) {
		310	if (isFolderOfTemplates(child)) {
		311	leaf = false;
		312	break;
		313	}
		314	}
		315	keys.add(new TemplateKey(d, leaf));
		316	}
311	}	317	}
312	DataObject d = kids[alreadyAdded];	318	return true;
313	Visibility v;
314	if (isFolderOfTemplates(d)) {
315	v = Visibility.LEAF;
316	for (DataObject child : ((DataFolder) d).getChildren()) {
317	if (isFolderOfTemplates(child)) {
318	v = Visibility.CATEGORY;
319	break;
320	}
321	}
322	} else {
323	v = Visibility.HIDE;
324	}
325	keys.add(new TemplateKey(d, v));
326	return false;
327	}	319	}
328		320
329	@Override protected Node createNodeForKey(TemplateKey k) {	321	@Override protected Node createNodeForKey(TemplateKey k) {
330	switch (k.visibility) {	322	return new FilterNode(k.d.getNodeDelegate(), k.leaf ? Children.LEAF : Children.create(new TemplateChildren((DataFolder) k.d), true));
331	case CATEGORY:
332	return new FilterNode(k.d.getNodeDelegate(), Children.create(new TemplateChildren((DataFolder) k.d), true));
333	case LEAF:
334	return new FilterNode(k.d.getNodeDelegate(), Children.LEAF);
335	default:
336	return null;
337	}
338	}	323	}
339		324
340	@Override public void actionPerformed (ActionEvent event) {	325	@Override public void actionPerformed (ActionEvent event) {
Lines 361-384 Link Here
361		346
362	}	347	}
363		348
364	private final class FileKey {	349	private final class FileChildren extends ChildFactory<DataObject> {
365	final DataObject d;
366	final boolean visible;
367	FileKey(DataObject d, boolean visible) {
368	this.d = d;
369	this.visible = visible;
370	}
371	@Override public boolean equals(Object o) {
372	if (!(o instanceof FileKey)) {
373	return false;
374	}
375	return d == ((FileKey) o).d && visible == ((FileKey) o).visible;
376	}
377	@Override public int hashCode() {
378	return d.hashCode();
379	}
380	}
381	private final class FileChildren extends ChildFactory<FileKey> {
382		350
383	private DataFolder root;	351	private DataFolder root;
384		352
Lines 387-412 Link Here
387	assert this.root != null : "Root can not be null"; //NOI18N	355	assert this.root != null : "Root can not be null"; //NOI18N
388	}	356	}
389		357
390	@Override protected boolean createKeys(List<FileKey> keys) {	358	@Override protected boolean createKeys(List<DataObject> keys) {
391	DataObject[] kids = root.getChildren();	359	for (DataObject dobj : root.getChildren()) {
392	int alreadyAdded = keys.size();	360	if (isTemplate(dobj) && OpenProjectList.isRecommended(projectRecommendedTypes, dobj.getPrimaryFile())) {
393	if (alreadyAdded >= kids.length) {	361	if (dobj instanceof DataShadow) {
394	return true;	362	dobj = ((DataShadow) dobj).getOriginal();
		363	}
		364	keys.add(dobj);
		365	}
395	}	366	}
396	DataObject dobj = kids[alreadyAdded];	367	return true;
397	if (isTemplate(dobj) && OpenProjectList.isRecommended(projectRecommendedTypes, dobj.getPrimaryFile())) {
398	if (dobj instanceof DataShadow) {
399	dobj = ((DataShadow) dobj).getOriginal();
400	}
401	keys.add(new FileKey(dobj, true));
402	} else {
403	keys.add(new FileKey(dobj, false));
404	}
405	return false;
406	}	368	}
407		369
408	@Override protected Node createNodeForKey(FileKey key) {	370	@Override protected Node createNodeForKey(DataObject d) {
409	return key.visible ? new FilterNode(key.d.getNodeDelegate(), Children.LEAF) : null;	371	return new FilterNode(d.getNodeDelegate(), Children.LEAF);
410	}	372	}
411		373
412	}	374	}

Lines 46-52 Link Here

(-)a/hudson/src/org/netbeans/modules/hudson/ui/nodes/HudsonJobNode.java (-14 / +4 lines)
46		46
47	import java.io.CharConversionException;	47	import java.io.CharConversionException;
48	import java.util.ArrayList;	48	import java.util.ArrayList;
49	import java.util.LinkedList;
50	import java.util.List;	49	import java.util.List;
51	import javax.swing.Action;	50	import javax.swing.Action;
52	import org.netbeans.modules.hudson.api.HudsonJob;	51	import org.netbeans.modules.hudson.api.HudsonJob;
Lines 94-117 Link Here
94	}	93	}
95	return Children.create(new ChildFactory<Object>() {	94	return Children.create(new ChildFactory<Object>() {
96	final Object WORKSPACE = new Object();	95	final Object WORKSPACE = new Object();
97	LinkedList<HudsonJobBuild> builds;
98	protected @Override boolean createKeys(List<Object> toPopulate) {	96	protected @Override boolean createKeys(List<Object> toPopulate) {
99	if (Thread.interrupted()) {	97	// XXX would be nicer to avoid adding this in case there is no remote workspace...
100	return true;	98	toPopulate.add(WORKSPACE);
101	} else if (builds == null) {	99	for (HudsonJobBuild b : job.getBuilds()) {
102	// XXX would be nicer to avoid adding this in case there is no remote workspace...
103	toPopulate.add(WORKSPACE);
104	builds = new LinkedList<HudsonJobBuild>(job.getBuilds());
105	return false;
106	} else if (builds.isEmpty()) {
107	return true;
108	} else {
109	// Processing one build at a time, make sure its result is known (blocking call).	100	// Processing one build at a time, make sure its result is known (blocking call).
110	HudsonJobBuild b = builds.removeFirst();
111	b.getResult();	101	b.getResult();
112	toPopulate.add(b);	102	toPopulate.add(b);
113	return false;
114	}	103	}
		104	return true;
115	}	105	}
116	protected @Override Node createNodeForKey(Object key) {	106	protected @Override Node createNodeForKey(Object key) {
117	if (key == WORKSPACE) {	107	if (key == WORKSPACE) {

Lines 155-166 Link Here

(-)a/maven/src/org/netbeans/modules/maven/nodes/ModulesNode.java (-12 / +3 lines)
155		155
156	@Override	156	@Override
157	protected boolean createKeys(final List<Wrapper> modules) {	157	protected boolean createKeys(final List<Wrapper> modules) {
158	List<String> all = project.getOriginalMavenProject().getModules();	158	for (String module : project.getOriginalMavenProject().getModules()) {
159	int alreadyAdded = modules.size();
160	if (alreadyAdded >= all.size()) {
161	return true;
162	}
163	String module = all.get(alreadyAdded);
164	File base = project.getOriginalMavenProject().getBasedir();	159	File base = project.getOriginalMavenProject().getBasedir();
165	File projDir = FileUtil.normalizeFile(new File(base, module));	160	File projDir = FileUtil.normalizeFile(new File(base, module));
166	FileObject fo = FileUtil.toFileObject(projDir);	161	FileObject fo = FileUtil.toFileObject(projDir);
Lines 174-180 Link Here
174	wr.isAggregator = NbMavenProject.TYPE_POM.equals(mp.getPackaging()) && !mp.getModules().isEmpty();	169	wr.isAggregator = NbMavenProject.TYPE_POM.equals(mp.getPackaging()) && !mp.getModules().isEmpty();
175	wr.provider = prj.getLookup().lookup(LogicalViewProvider.class);	170	wr.provider = prj.getLookup().lookup(LogicalViewProvider.class);
176	modules.add(wr);	171	modules.add(wr);
177	return false;
178	}	172	}
179	} catch (IllegalArgumentException ex) {	173	} catch (IllegalArgumentException ex) {
180	ex.printStackTrace();//TODO log ?	174	ex.printStackTrace();//TODO log ?
Lines 184-198 Link Here
184	} else {	178	} else {
185	//TODO broken module reference.. show as such..	179	//TODO broken module reference.. show as such..
186	}	180	}
187	modules.add(new Wrapper()); // broken submodule ref	181	}
188	return false;	182	return true;
189	}	183	}
190		184
191	@Override	185	@Override
192	protected Node createNodeForKey(Wrapper wr) {	186	protected Node createNodeForKey(Wrapper wr) {
193	if (wr.proj == null) {
194	return null;
195	}
196	return new ProjectFilterNode(project, wr.proj, wr.provider.createLogicalView(), wr.isAggregator);	187	return new ProjectFilterNode(project, wr.proj, wr.provider.createLogicalView(), wr.isAggregator);
197	}	188	}
198		189

Lines 49-54 Link Here

(-)a/openide.nodes/apichanges.xml (+23 lines)
49	<apidef name="nodes">Nodes API</apidef>	49	<apidef name="nodes">Nodes API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="ChildFactory.incremental">
		53	<api name="nodes"/>
		54	<summary><code>ChildFactory.createKeys</code> better supports incremental display</summary>
		55	<version major="7" minor="27"/>
		56	<date year="2012" month="1" day="3"/>
		57	<author login="jglick"/>
		58	<compatibility modification="yes" semantic="compatible">
		59	<p>
		60	Existing factories which returned false from <code>createKeys</code>
		61	may continue to do so with the same behavior, but should consider
		62	just producing all keys within the body of the loop instead.
		63	</p>
		64	</compatibility>
		65	<description>
		66	<p>
		67	An implementation of <code>ChildFactory.createKeys</code> may now
		68	use <code>List.add</code> a number of times and return true at the
		69	end, while still displaying keys incrementally.
		70	</p>
		71	</description>
		72	<class package="org.openide.nodes" name="ChildFactory"/>
		73	<issue number="206556"/>
		74	</change>
52	<change id="NodeOperation.showCustomEditorDialog">	75	<change id="NodeOperation.showCustomEditorDialog">
53	<api name="nodes"/>	76	<api name="nodes"/>
54	<summary>A way to show a custom editor dialog for a property</summary>	77	<summary>A way to show a custom editor dialog for a property</summary>

Lines 164-169 Link Here

(-)a/openide.nodes/src/org/openide/nodes/AsynchChildren.java (-3 / +29 lines)
164	volatile boolean cancelled = false;	164	volatile boolean cancelled = false;
165	volatile boolean notified;	165	volatile boolean notified;
166	private final Object notifyLock = new Object();	166	private final Object notifyLock = new Object();
		167	private static final class Stop extends RuntimeException {}
167	public void run() {	168	public void run() {
168	boolean fail = cancelled \|\| Thread.interrupted();	169	boolean fail = cancelled \|\| Thread.interrupted();
169	logger.log (Level.FINE, "Running background children creation on " + //NOI18N	170	logger.log (Level.FINE, "Running background children creation on " + //NOI18N
Lines 172-178 Link Here
172	setKeys (Collections.<T>emptyList());	173	setKeys (Collections.<T>emptyList());
173	return;	174	return;
174	}	175	}
175	List <T> keys = new LinkedList <T> ();	176	List <T> keys = new LinkedList <T> () {
		177	@Override public boolean add(T e) {
		178	if (cancelled \|\| Thread.interrupted()) {
		179	throw new Stop();
		180	}
		181	super.add(e);
		182	LinkedList<Object> newKeys = new LinkedList<Object>(this);
		183	Node n = factory.getWaitNode();
		184	if (n != null) {
		185	newKeys.add(n);
		186	}
		187	setKeys(newKeys);
		188	return true;
		189	}
		190	};
176	boolean done;	191	boolean done;
177	do {	192	do {
178	synchronized (notifyLock) {	193	synchronized (notifyLock) {
Lines 185-196 Link Here
185	setKeys (Collections.<T>emptyList());	200	setKeys (Collections.<T>emptyList());
186	return;	201	return;
187	}	202	}
188	done = factory.createKeys (keys);	203	try {
		204	done = factory.createKeys(keys);
		205	} catch (Stop stop) {
		206	done = true;
		207	}
189	if (cancelled \|\| Thread.interrupted()) {	208	if (cancelled \|\| Thread.interrupted()) {
190	setKeys (Collections.<T>emptyList());	209	setKeys (Collections.<T>emptyList());
191	return;	210	return;
192	}	211	}
193	setKeys (new LinkedList <T> (keys));	212	LinkedList<Object> newKeys = new LinkedList<Object>(keys);
		213	if (!done) {
		214	Node n = factory.getWaitNode();
		215	if (n != null) {
		216	newKeys.add(n);
		217	}
		218	}
		219	setKeys (newKeys);
194	} while (!done && !Thread.interrupted() && !cancelled);	220	} while (!done && !Thread.interrupted() && !cancelled);
195	initialized = done;	221	initialized = done;
196	}	222	}