Attachment #75996 for bug #134558

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

Lines 246-252 Link Here

(-)a/java.project/nbproject/project.xml (-1 / +1 lines)
246	<compile-dependency/>	246	<compile-dependency/>
247	<run-dependency>	247	<run-dependency>
248	<release-version>3</release-version>	248	<release-version>3</release-version>
249	<specification-version>3.3</specification-version>	249	<specification-version>3.20</specification-version>
250	</run-dependency>	250	</run-dependency>
251	</dependency>	251	</dependency>
252	</module-dependencies>	252	</module-dependencies>

Lines 91-96 Link Here

(-)a/java.project/src/org/netbeans/spi/java/project/support/ui/PackageRootNode.java (-1 / +5 lines)
91	import org.openide.util.lookup.ProxyLookup;	91	import org.openide.util.lookup.ProxyLookup;
92	import org.openidex.search.SearchInfo;	92	import org.openidex.search.SearchInfo;
93	import org.openidex.search.SearchInfoFactory;	93	import org.openidex.search.SearchInfoFactory;
		94	import org.openidex.search.Utils;
94		95
95	/** Node displaying a packages in given SourceGroup	96	/** Node displaying a packages in given SourceGroup
96	* @author Petr Hrebejk	97	* @author Petr Hrebejk
Lines 449-455 Link Here
449	return new AlwaysSearchableSearchInfo(i);	450	return new AlwaysSearchableSearchInfo(i);
450	}	451	}
451		452
452	private static final class AlwaysSearchableSearchInfo implements SearchInfo {	453	private static final class AlwaysSearchableSearchInfo implements SearchInfo.Files {
453		454
454	private final SearchInfo delegate;	455	private final SearchInfo delegate;
455		456
Lines 465-470 Link Here
465	return delegate.objectsToSearch();	466	return delegate.objectsToSearch();
466	}	467	}
467		468
		469	public Iterator<FileObject> filesToSearch() {
		470	return Utils.getFileObjectsIterator(delegate);
		471	}
468	}	472	}
469		473
470	}	474	}




<!-- ACTUAL CHANGES BEGIN HERE: -->

  <changes>

       <change id="SearchUtils">
        <api name="search"/>
        <summary>Added utility class <code>Utils</code></summary>
        <version major="3" minor="20"/>
        <date day="13" month="1" year="2009"/>
        <author login="kaktus"/>
        <compatibility addition="yes"/>
        <description>
            <p>
                Class <code>Utils</code> made public with one public static method
                <code>getFileObjectsIterator(SearchInfo si)</code>. This utility
                method returns <code>Iterator</code> of <code>FileObject</code>s
                for the provided <code>SearchInfo</code>. This change simplifies
                the work with <code>SearchInfo</code> implementations.
            </p>
        </description>
        <class package="org.openidex.search" name="Utils"/>
    </change>

      <change id="SearchInfo.Files">
        <api name="search"/>
        <summary>Added interface <code>SearchInfo.Files</code></summary>
        <version major="3" minor="20"/>
        <date day="13" month="1" year="2009"/>
        <author login="kaktus"/>
        <compatibility addition="yes"/>
        <description>
            <p>
                Added <code>SearchInfo.Files</code> interface which extends
                <code>SearchInfo</code> interface. It adds method
                <code>filesToSearch()</code> to provide <code>FileObject</code>s
                which should be searched. This change allows to operate <code>FileObject</code>s
                in the search mechanism instead of <code>DataObject</code>s and
                as a result improves search performance.
            </p>
        </description>
        <class package="org.openidex.search" name="SearchInfo.Files"/>
        <issue number="134558"/>
    </change>

 
     <change id="SearchInfoFactory.createCompoundSearchInfo">

Lines 1-5 Link Here

(-)a/o.openidex.util/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.openidex.util/3	2	OpenIDE-Module: org.openidex.util/3
3	OpenIDE-Module-Localizing-Bundle: org/openidex/resources/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/openidex/resources/Bundle.properties
4	OpenIDE-Module-Specification-Version: 3.16	4	OpenIDE-Module-Specification-Version: 3.20
5	AutoUpdate-Essential-Module: true	5	AutoUpdate-Essential-Module: true




import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;

/**
 *
 * @author  Marian Petras
 */
class CompoundSearchInfo implements SearchInfo.Files {

    /** */
    private final SearchInfo[] elements;

    /**
     */
    public Iterator<DataObject> objectsToSearch() {
        return Utils.toDataObjectIterator(filesToSearch());
    }

    /**
     */
    public Iterator<FileObject> filesToSearch() {
        if (elements == null) {
            return Collections.<FileObject>emptyList().iterator();
        }
        
        List<SearchInfo> searchableElements = new ArrayList<SearchInfo>(elements.length);





import java.util.Iterator;
import java.util.NoSuchElementException;
import org.openide.filesystems.FileObject;

/**
 *
 * @author  Marian Petras
 */
class CompoundSearchIterator implements Iterator<FileObject> {

    /** */
    private final SearchInfo[] elements;
    /** */
    private int elementIndex;
    /** */
    private Iterator<FileObject> elementIterator;
    /** */
    private FileObject nextObject;
    /** */
    private boolean upToDate;


            upToDate = true;                //hasNext() returns always false
        } else {
            this.elements = elements;
            elementIterator = Utils.getFileObjectsIterator(elements[elementIndex = 0]);
            upToDate = false;
        }
    }


    /**
     */
    public FileObject next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

                break;
            }
            
            elementIterator = Utils.getFileObjectsIterator(elements[elementIndex]);
        }
        
        if (elementIndex < elements.length) {




package org.openidex.search;

import java.util.Iterator;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;

/**

     *          to be searched
     */
    public Iterator<DataObject> objectsToSearch();

    /**
     * Additionally defines which <code>FileObject</code>s should be searched.
     *
     * @since org.openidex.util/3 3.20
     * @author kaktus
     */
    public interface Files extends SearchInfo{

    /**
     * Specifies which <code>FileObject</code>s should be searched.
     * The returned <code>Iterator</code> needn't implement method
     * {@link java.util.Iterator#remove remove()} (i.e. it may throw
     * <code>UnsupportedOperationException</code> instead of actual
     * implementation).
     *
     * @return  iterator which iterates over <code>FileObject</code>s
     *          to be searched
     */
    public Iterator<FileObject> filesToSearch();
    }
}

Lines 52-58 Link Here

(-)a/o.openidex.util/src/org/openidex/search/SimpleSearchInfo.java (-3 / +12 lines)
52	*	52	*
53	* @author Marian Petras	53	* @author Marian Petras
54	*/	54	*/
55	class SimpleSearchInfo implements SearchInfo {	55	class SimpleSearchInfo implements SearchInfo.Files {
56		56
57	/**	57	/**
58	* Empty search info object.	58	* Empty search info object.
Lines 61-73 Link Here
61	* (returned by method	61	* (returned by method
62	* {@link SearchInfo#objectsToSearch objectsToSearch()}) has no elements.	62	* {@link SearchInfo#objectsToSearch objectsToSearch()}) has no elements.
63	*/	63	*/
64	static final SearchInfo EMPTY_SEARCH_INFO	64	static final SearchInfo.Files EMPTY_SEARCH_INFO
65	= new SearchInfo() {	65	= new SearchInfo.Files() {
66	public boolean canSearch() {	66	public boolean canSearch() {
67	return true;	67	return true;
68	}	68	}
69	public Iterator<DataObject> objectsToSearch() {	69	public Iterator<DataObject> objectsToSearch() {
70	return Collections.<DataObject>emptyList().iterator();	70	return Collections.<DataObject>emptyList().iterator();
		71	}
		72	public Iterator<FileObject> filesToSearch() {
		73	return Collections.<FileObject>emptyList().iterator();
71	}	74	}
72	};	75	};
73		76
Lines 112-117 Link Here
112	/**	115	/**
113	*/	116	*/
114	public Iterator<DataObject> objectsToSearch() {	117	public Iterator<DataObject> objectsToSearch() {
		118	return Utils.toDataObjectIterator(filesToSearch());
		119	}
		120
		121	/**
		122	*/
		123	public Iterator<FileObject> filesToSearch() {
115	return new SimpleSearchIterator(rootFolder,	124	return new SimpleSearchIterator(rootFolder,
116	recursive,	125	recursive,
117	filters != null ? Arrays.asList(filters)	126	filters != null ? Arrays.asList(filters)




import java.util.NoSuchElementException;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;

/**
 *
 * @author  Marian Petras
 */
class SimpleSearchIterator implements Iterator<FileObject> {

    /** current enumeration of children */
    private Enumeration<? extends FileObject> childrenEnum;
    /**
     * filters to be applied on the current enumeration of children
     * ({@link #childrenEnum})

    /** */
    private final boolean recursive;
    /** stack of the ancestor folders' children enumerations */
    private final List<Enumeration<? extends FileObject>> enums
            = new ArrayList<Enumeration<? extends FileObject>>();            //unsynced stack
    /**
     * stack of filter lists to be applied on children of the ancestor folders
     * ({@link #enums})

     * <code>DataObject</code> to be returned the next time method
     * {@link #next()} is called
     */
    private FileObject nextObject;

    /**
     */
    SimpleSearchIterator(DataFolder folder,
                         boolean recursive,
                         List<FileObjectFilter> filters) {
        this.childrenEnum = folder.getPrimaryFile().getChildren(false);
        this.recursive = recursive;
        this.filters = (filters != null) ? new ArrayList<FileObjectFilter>(filters)
                                         : null;


    /** 
     */
    public FileObject next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        assert childrenEnum != null;
        do {
            if (childrenEnum.hasMoreElements()) {
                FileObject file = childrenEnum.nextElement();
                FileObject file = dataObject.getPrimaryFile();
                if (file.isFolder()) {
                    if (!recursive) {
                        continue;

                        filterLists.add(null);
                    }
                    enums.add(childrenEnum);
                    childrenEnum = file.getChildren(false);
                } else {
                    if ((filters != null) && !checkFileFilters(file)) {
                        continue;
                    }
                    
                    nextObject = file;
                    break;
                }
            } else {

Lines 45-50 Link Here

(-)a/o.openidex.util/src/org/openidex/search/SubnodesSearchInfo.java (-4 / +11 lines)
45	import java.util.Collections;	45	import java.util.Collections;
46	import java.util.Iterator;	46	import java.util.Iterator;
47	import java.util.List;	47	import java.util.List;
		48	import org.openide.filesystems.FileObject;
48	import org.openide.loaders.DataObject;	49	import org.openide.loaders.DataObject;
49	import org.openide.nodes.Node;	50	import org.openide.nodes.Node;
50		51
Lines 52-58 Link Here
52	*	53	*
53	* @author Marian Petras	54	* @author Marian Petras
54	*/	55	*/
55	final class SubnodesSearchInfo implements SearchInfo {	56	final class SubnodesSearchInfo implements SearchInfo.Files {
56		57
57	/** */	58	/** */
58	private final Node node;	59	private final Node node;
Lines 80-88 Link Here
80	/**	81	/**
81	*/	82	*/
82	public Iterator<DataObject> objectsToSearch() {	83	public Iterator<DataObject> objectsToSearch() {
		84	return Utils.toDataObjectIterator(filesToSearch());
		85	}
		86
		87	/**
		88	*/
		89	public Iterator<FileObject> filesToSearch() {
83	final Node[] nodes = node.getChildren().getNodes(true);	90	final Node[] nodes = node.getChildren().getNodes(true);
84	if (nodes.length == 0) {	91	if (nodes.length == 0) {
85	return SimpleSearchInfo.EMPTY_SEARCH_INFO.objectsToSearch();	92	return SimpleSearchInfo.EMPTY_SEARCH_INFO.filesToSearch();
86	}	93	}
87		94
88	List<SearchInfo> searchInfoElements = new ArrayList<SearchInfo>(nodes.length);	95	List<SearchInfo> searchInfoElements = new ArrayList<SearchInfo>(nodes.length);
Lines 96-104 Link Here
96	final int size = searchInfoElements.size();	103	final int size = searchInfoElements.size();
97	switch (size) {	104	switch (size) {
98	case 0:	105	case 0:
99	return Collections.<DataObject>emptyList().iterator();	106	return Collections.<FileObject>emptyList().iterator();
100	case 1:	107	case 1:
101	return searchInfoElements.get(0).objectsToSearch();	108	return Utils.getFileObjectsIterator(searchInfoElements.get(0));
102	default:	109	default:
103	return new CompoundSearchIterator(	110	return new CompoundSearchIterator(
104	searchInfoElements.toArray(new SearchInfo[size]));	111	searchInfoElements.toArray(new SearchInfo[size]));

Lines 41-54 Link Here

(-)a/o.openidex.util/src/org/openidex/search/Utils.java (-5 / +45 lines)
41		41
42	package org.openidex.search;	42	package org.openidex.search;
43		43
		44	import java.util.HashSet;
		45	import java.util.Iterator;
		46	import java.util.Set;
		47	import org.openide.filesystems.FileObject;
44	import org.openide.loaders.DataFolder;	48	import org.openide.loaders.DataFolder;
		49	import org.openide.loaders.DataObject;
		50	import org.openide.loaders.DataObjectNotFoundException;
45	import org.openide.nodes.Node;	51	import org.openide.nodes.Node;
46		52
47	/**	53	/**
48	*	54	* Search API utility class.
49	* @author Marian Petras	55	*
50	*/	56	* @since org.openidex.util/3 3.20
51	final class Utils {	57	* @author Marian Petras
		58	* @author cactus
		59	*/
		60	public final class Utils {
52		61
53	/**	62	/**
54	*/	63	*/
Lines 72-75 Link Here
72	}	81	}
73	}	82	}
74		83
		84	/**
		85	* Returns <code>Iterator</code> of <code>FileObject</code>'s for the provided <code>SearchInfo</code>.
		86	* If provided <code>SearchInfo</code> object is implementation of <code>SearchInfo.Files</code> interface
		87	* then the result of method <code>SearchInfo.Files.filesToSearch</code> is returned. Otherwise the objects
		88	* are getting from the <code>SearchInfo.objectsToSearch</code> method.
		89	*
		90	* @param si <code>SearchInfo</code> object to return the iterator for
		91	* @return iterator which iterates over <code>FileObject</code>s
		92	* @since org.openidex.util/3 3.20
		93	*/
		94	public static Iterator<FileObject> getFileObjectsIterator(SearchInfo si){
		95	if (si instanceof SearchInfo.Files){
		96	return ((SearchInfo.Files)si).filesToSearch();
		97	}else{
		98	Set<FileObject> set = new HashSet<FileObject>();
		99	for(Iterator<DataObject> iter = si.objectsToSearch(); iter.hasNext();){
		100	set.add(iter.next().getPrimaryFile());
		101	}
		102	return set.iterator();
		103	}
		104	}
		105
		106	static Iterator<DataObject> toDataObjectIterator(Iterator<FileObject> itFO){
		107	Set<DataObject> set = new HashSet<DataObject>();
		108	while(itFO.hasNext()){
		109	try {
		110	set.add(DataObject.find(itFO.next()));
		111	} catch (DataObjectNotFoundException ex){}
		112	}
		113	return set.iterator();
		114	}
75	}	115	}




package org.openidex.search;

import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.netbeans.junit.MockServices;
import org.netbeans.junit.NbTestCase;
import org.openide.filesystems.FileObject;

    }
    
    public void testEmptyList() {
        SearchInfo.Files searchInfo = new CompoundSearchInfo(new SearchInfo[0]);
        assertFalse(searchInfo.canSearch());
        assertFalse(searchInfo.objectsToSearch().hasNext());
        assertFalse(searchInfo.filesToSearch().hasNext());
    }
    
    public void testOneItemList() throws IOException {

        dir.createData("c", DummyDataLoader.dummyExt);
        DataFolder folder = DataFolder.findFolder(dir);
        
        
        SearchInfo refSearchInfo;
        SearchInfo testSearchInfo;
        boolean refCanSearch;
        boolean testCanSearch;
        Iterator refIt;
        Iterator testIt;
        Set testSet = new HashSet();
        
        
        refSearchInfo = new SimpleSearchInfo(folder, false, null);
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
        assertTrue(testSearchInfo.canSearch());

        for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }
        refIt = refSearchInfo.objectsToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
        }
        assertTrue(testSet.isEmpty());
            assertEquals(refHasNext, testHasNext);

            if (!refHasNext) {
                break;
            }

            Object refObj = refIt.next();
            Object testObj = testIt.next();
            assertSame(refObj, testObj);
        }
        assertEquals(3, testIterationsCount);
        
        
        refSearchInfo = new SimpleSearchInfo(folder, false, null) {
            public boolean canSearch() {
                return false;
            }
        };
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
        assertEquals(refSearchInfo.canSearch(), testSearchInfo.canSearch());
    }

    public void testOneItemFilesList() throws IOException {
        FileSystem fs = FileUtil.createMemoryFileSystem();
        FileObject fsRoot = fs.getRoot();

        FileObject dir = fsRoot.createFolder("dir");
        dir.createData("a", DummyDataLoader.dummyExt);
        dir.createData("b", DummyDataLoader.dummyExt);
        dir.createData("c", DummyDataLoader.dummyExt);
        DataFolder folder = DataFolder.findFolder(dir);

        SearchInfo.Files refSearchInfo;
        SearchInfo.Files testSearchInfo;
        Iterator refIt;
        Iterator testIt;
        Set testSet = new HashSet();

        refSearchInfo = new SimpleSearchInfo(folder, false, null);
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
        assertTrue(testSearchInfo.canSearch());

        for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }
        refIt = refSearchInfo.filesToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
        }
        assertTrue(testSet.isEmpty());

        refSearchInfo = new SimpleSearchInfo(folder, false, null) {
            public boolean canSearch() {
                return false;
            }
        };
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
        assertEquals(refSearchInfo.canSearch(), testSearchInfo.canSearch());
    }
    
    public void testMultipleItemsList() throws IOException {

        SearchInfo testSearchInfo;
        Iterator refIt;
        Iterator testIt;
        int testIterationsCount;
        
        
        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
        refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
                                                                  refSearchInfo2});
        assertTrue(testSearchInfo.canSearch());

        Set testSet = new HashSet();
        for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }

        refIt = refSearchInfo1.objectsToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
            assertSame(refIt.next(), testIt.next());
            testIterationsCount++;
        }
        assertTrue(testIt.hasNext());
        refIt = refSearchInfo2.objectsToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
            assertSame(refIt.next(), testIt.next());
            testIterationsCount++;
        }
        assertTrue(testSet.isEmpty());


        
        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
        refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {
            public boolean canSearch() {

        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
                                                                  refSearchInfo2});
        assertTrue(testSearchInfo.canSearch());

        testSet.clear();
        for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }

        refIt = refSearchInfo1.objectsToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
            assertSame(refIt.next(), testIt.next());
            testIterationsCount++;
        }
        assertTrue(testSet.isEmpty());

        
        
        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
            public boolean canSearch() {

                                                                  refSearchInfo2});
        assertTrue(testSearchInfo.canSearch());
        
        testSet.clear();
        for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }
        refIt = refSearchInfo2.objectsToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
            assertSame(refIt.next(), testIt.next());
            testIterationsCount++;
        }
        assertTrue(testSet.isEmpty());
        assertEquals(2, testIterationsCount);
        
        
        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {

                                                                  refSearchInfo2});
        assertFalse(testSearchInfo.canSearch());
    }

    public void testMultipleItemsFilesList() throws IOException {
        FileSystem fs = FileUtil.createMemoryFileSystem();
        FileObject fsRoot = fs.getRoot();

        FileObject dir1 = fsRoot.createFolder("dir1");
        dir1.createData("1a", DummyDataLoader.dummyExt);
        dir1.createData("1b", DummyDataLoader.dummyExt);
        dir1.createData("1c", DummyDataLoader.dummyExt);
        DataFolder folder1 = DataFolder.findFolder(dir1);

        FileObject dir2 = fsRoot.createFolder("dir2");
        dir2.createData("2a", DummyDataLoader.dummyExt);
        dir2.createData("2b", DummyDataLoader.dummyExt);
        DataFolder folder2 = DataFolder.findFolder(dir2);


        SearchInfo.Files refSearchInfo1, refSearchInfo2;
        SearchInfo.Files testSearchInfo;
        Iterator refIt;
        Iterator testIt;

        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
        refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
                                                                  refSearchInfo2});
        assertTrue(testSearchInfo.canSearch());

        Set testSet = new HashSet();
        for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }

        refIt = refSearchInfo1.filesToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
        }
        refIt = refSearchInfo2.filesToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
        }
        assertTrue(testSet.isEmpty());


        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
        refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {
            public boolean canSearch() {
                return false;
            }
        };
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
                                                                  refSearchInfo2});
        assertTrue(testSearchInfo.canSearch());

        testSet.clear();
        for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }

        refIt = refSearchInfo1.filesToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
        }
        assertTrue(testSet.isEmpty());


        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
            public boolean canSearch() {
                return false;
            }
        };
        refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
                                                                  refSearchInfo2});
        assertTrue(testSearchInfo.canSearch());

        testSet.clear();
        for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
            testSet.add(testIt.next());
        }
        refIt = refSearchInfo2.filesToSearch();
        while (refIt.hasNext()) {
            assertTrue(testSet.remove(refIt.next()));
        }
        assertTrue(testSet.isEmpty());


        refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
            public boolean canSearch() {
                return false;
            }
        };
        refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {
            public boolean canSearch() {
                return false;
            }
        };
        testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
                                                                  refSearchInfo2});
        assertFalse(testSearchInfo.canSearch());
    }

}

Lines 211-217 Link Here

(-)a/projectui/nbproject/project.xml (-1 / +1 lines)
211	<compile-dependency/>	211	<compile-dependency/>
212	<run-dependency>	212	<run-dependency>
213	<release-version>3</release-version>	213	<release-version>3</release-version>
214	<specification-version>3.3</specification-version>	214	<specification-version>3.20</specification-version>
215	</run-dependency>	215	</run-dependency>
216	</dependency>	216	</dependency>
217	</module-dependencies>	217	</module-dependencies>

Lines 97-102 Link Here

(-)a/projectui/src/org/netbeans/modules/project/ui/ProjectsRootNode.java (-1 / +5 lines)
97	import org.openidex.search.FileObjectFilter;	97	import org.openidex.search.FileObjectFilter;
98	import org.openidex.search.SearchInfo;	98	import org.openidex.search.SearchInfo;
99	import org.openidex.search.SearchInfoFactory;	99	import org.openidex.search.SearchInfoFactory;
		100	import org.openidex.search.Utils;
100		101
101	/** Root node for list of open projects	102	/** Root node for list of open projects
102	*/	103	*/
Lines 734-740 Link Here
734	return new AlwaysSearchableSearchInfo(p);	735	return new AlwaysSearchableSearchInfo(p);
735	}	736	}
736		737
737	private static final class AlwaysSearchableSearchInfo implements SearchInfo {	738	private static final class AlwaysSearchableSearchInfo implements SearchInfo.Files {
738		739
739	private final SearchInfo delegate;	740	private final SearchInfo delegate;
740		741
Lines 763-768 Link Here
763	return delegate.objectsToSearch();	764	return delegate.objectsToSearch();
764	}	765	}
765		766
		767	public Iterator<FileObject> filesToSearch() {
		768	return Utils.getFileObjectsIterator(delegate);
		769	}
766	}	770	}
767		771
768	}	772	}

Lines 42-48 Link Here

(-)a/utilities.project/src/org/netbeans/modules/search/project/SearchScopeMainProject.java (-1 lines)
42	package org.netbeans.modules.search.project;	42	package org.netbeans.modules.search.project;
43		43
44	import org.netbeans.api.project.Project;	44	import org.netbeans.api.project.Project;
45	import org.netbeans.api.project.ui.OpenProjects;
46	import org.netbeans.api.project.ui.OpenProjects;	45	import org.netbeans.api.project.ui.OpenProjects;
47	import org.openide.util.NbBundle;	46	import org.openide.util.NbBundle;
48	import org.openidex.search.SearchInfo;	47	import org.openidex.search.SearchInfo;

Lines 183-189 Link Here

(-)a/utilities/nbproject/project.xml (-1 / +1 lines)
183	<compile-dependency/>	183	<compile-dependency/>
184	<run-dependency>	184	<run-dependency>
185	<release-version>3</release-version>	185	<release-version>3</release-version>
186	<specification-version>3.3</specification-version>	186	<specification-version>3.20</specification-version>
187	</run-dependency>	187	</run-dependency>
188	</dependency>	188	</dependency>
189	</module-dependencies>	189	</module-dependencies>

Lines 561-573 Link Here

(-)a/utilities/src/org/netbeans/modules/search/BasicSearchCriteria.java (-8 / +12 lines)
561	* criteria, {@code false} otherwise	561	* criteria, {@code false} otherwise
562	*/	562	*/
563	boolean matches(DataObject dataObj) {	563	boolean matches(DataObject dataObj) {
		564	return matches(dataObj.getPrimaryFile());
		565	}
		566
		567	boolean matches(FileObject fileObj) {
564	lastCharset = null;	568	lastCharset = null;
565		569
566	if (!dataObj.isValid()) {	570	if (!fileObj.isValid()) {
567	return false;	571	return false;
568	}	572	}
569		573
570	FileObject fileObj = dataObj.getPrimaryFile();
571	if (fileObj.isFolder() \|\| !fileObj.isValid() \|\| (isFullText() && !isTextFile(fileObj))) {	574	if (fileObj.isFolder() \|\| !fileObj.isValid() \|\| (isFullText() && !isTextFile(fileObj))) {
572	return false;	575	return false;
573	}	576	}
Lines 580-586 Link Here
580		583
581	/* Check the file's content: */	584	/* Check the file's content: */
582	if (textPatternValid	585	if (textPatternValid
583	&& !checkFileContent(fileObj, dataObj)) {	586	&& !checkFileContent(fileObj)) {
584	return false;	587	return false;
585	}	588	}
586		589
Lines 635-649 Link Here
635	* Checks whether the file's content matches the text pattern.	638	* Checks whether the file's content matches the text pattern.
636	*	639	*
637	* @param fileObj file whose content is to be checked	640	* @param fileObj file whose content is to be checked
638	* @param dataObj {@code DataObject} corresponding to the file
639	* @return {@code true} if the file contains at least one substring	641	* @return {@code true} if the file contains at least one substring
640	* matching the pattern, {@code false} otherwise	642	* matching the pattern, {@code false} otherwise
641	*/	643	*/
642	private boolean checkFileContent(FileObject fileObj, DataObject dataObj) {	644	private boolean checkFileContent(FileObject fileObj) {
643	boolean firstMatch = true;	645	boolean firstMatch = true;
644	SearchPattern searchPattern = null;	646	SearchPattern searchPattern = null;
645	ArrayList<TextDetail> txtDetails = null;	647	ArrayList<TextDetail> txtDetails = null;
646		648	DataObject dObj = null;
		649
647	LineNumberReader reader = null;	650	LineNumberReader reader = null;
648	try {	651	try {
649	reader = getFileObjectReader(fileObj);	652	reader = getFileObjectReader(fileObj);
Lines 656-663 Link Here
656	searchPattern = createSearchPattern();	659	searchPattern = createSearchPattern();
657	txtDetails = new ArrayList<TextDetail>(5);	660	txtDetails = new ArrayList<TextDetail>(5);
658	firstMatch = false;	661	firstMatch = false;
		662	dObj = DataObject.find(fileObj);
659	}	663	}
660	TextDetail det = new TextDetail(dataObj, searchPattern);	664	TextDetail det = new TextDetail(dObj, searchPattern);
661	det.setLine(reader.getLineNumber());	665	det.setLine(reader.getLineNumber());
662	det.setLineText(line);	666	det.setLineText(line);
663	int start = matcher.start();	667	int start = matcher.start();
Lines 669-675 Link Here
669	}	673	}
670	if (txtDetails != null) {	674	if (txtDetails != null) {
671	txtDetails.trimToSize();	675	txtDetails.trimToSize();
672	getDetailsMap().put(dataObj, txtDetails);	676	getDetailsMap().put(dObj, txtDetails);
673	return true;	677	return true;
674	} else {	678	} else {
675	return false;	679	return false;

Lines 45-52 Link Here

(-)a/utilities/src/org/netbeans/modules/search/SpecialSearchGroup.java (-9 / +35 lines)
45	import java.util.Collection;	45	import java.util.Collection;
46	import java.util.Iterator;	46	import java.util.Iterator;
47	import java.util.LinkedList;	47	import java.util.LinkedList;
		48	import org.openide.filesystems.FileObject;
48	import org.openide.loaders.DataObject;	49	import org.openide.loaders.DataObject;
49	import org.openidex.search.DataObjectSearchGroup;	50	import org.openidex.search.DataObjectSearchGroup;
		51	import org.openide.loaders.DataObjectNotFoundException;
		52	import org.openide.util.Exceptions;
		53	import org.openidex.search.FileObjectSearchGroup;
		54	import org.openidex.search.SearchInfo;
50	import org.openidex.search.SearchType;	55	import org.openidex.search.SearchType;
51		56
52	/**	57	/**
Lines 54-60 Link Here
54	* @author Marian Petras	59	* @author Marian Petras
55	* @author kaktus	60	* @author kaktus
56	*/	61	*/
57	final class SpecialSearchGroup extends DataObjectSearchGroup {	62	final class SpecialSearchGroup extends FileObjectSearchGroup {
58		63
59	final BasicSearchCriteria basicCriteria;	64	final BasicSearchCriteria basicCriteria;
60	final boolean hasExtraSearchTypes;	65	final boolean hasExtraSearchTypes;
Lines 86-96 Link Here
86	@Override	91	@Override
87	protected void prepareSearch(){	92	protected void prepareSearch(){
88	searchItems = new LinkedList();	93	searchItems = new LinkedList();
89	for (Iterator<DataObject> j = searchScope.getSearchInfo().objectsToSearch(); j.hasNext(); ) {	94	SearchInfo sInfo = searchScope.getSearchInfo();
90	if (stopped) {	95	if (sInfo instanceof SearchInfo.Files){
91	return;	96	for (Iterator j = ((SearchInfo.Files)sInfo).filesToSearch(); j.hasNext(); ) {
		97	if (stopped) {
		98	return;
		99	}
		100	searchItems.add(j.next());
92	}	101	}
93	searchItems.add(j.next());	102	} else {
		103	for (Iterator<DataObject> j = sInfo.objectsToSearch(); j.hasNext(); ) {
		104	if (stopped) {
		105	return;
		106	}
		107	searchItems.add(j.next());
		108	}
94	}	109	}
95	}	110	}
96		111
Lines 102-108 Link Here
102	if (stopped) {	117	if (stopped) {
103	return;	118	return;
104	}	119	}
105	processSearchObject(/DataObject/ searchItems.poll());	120	processSearchObject(searchItems.poll());
106	notifyProgress(index++);	121	notifyProgress(index++);
107	}	122	}
108	}	123	}
Lines 122-130 Link Here
122	protected void processSearchObject(Object searchObject) {	137	protected void processSearchObject(Object searchObject) {
123	if (!hasExtraSearchTypes) {	138	if (!hasExtraSearchTypes) {
124	assert basicCriteria != null;	139	assert basicCriteria != null;
125	DataObject dataObj = (DataObject) searchObject;	140	if (searchObject instanceof DataObject){
126	if (basicCriteria.matches(dataObj)) {	141	DataObject dataObj = (DataObject) searchObject;
127	notifyMatchingObjectFound(dataObj);	142	if (basicCriteria.matches(dataObj)) {
		143	notifyMatchingObjectFound(dataObj);
		144	}
		145	} else if (searchObject instanceof FileObject){
		146	FileObject fileObj = (FileObject) searchObject;
		147	if (basicCriteria.matches(fileObj)) {
		148	try {
		149	notifyMatchingObjectFound(DataObject.find(fileObj));
		150	} catch (DataObjectNotFoundException ex) {
		151	Exceptions.printStackTrace(ex);
		152	}
		153	}
128	}	154	}
129	return;	155	return;
130	}	156	}

Return to bug 134558

Lines 104-109 Link Here

(-)a/o.openidex.util/apichanges.xml (+40 lines)
104	<!-- ACTUAL CHANGES BEGIN HERE: -->	104	<!-- ACTUAL CHANGES BEGIN HERE: -->
105		105
106	<changes>	106	<changes>
		107
		108	<change id="SearchUtils">
		109	<api name="search"/>
		110	<summary>Added utility class <code>Utils</code></summary>
		111	<version major="3" minor="20"/>
		112	<date day="13" month="1" year="2009"/>
		113	<author login="kaktus"/>
		114	<compatibility addition="yes"/>
		115	<description>
		116	<p>
		117	Class <code>Utils</code> made public with one public static method
		118	<code>getFileObjectsIterator(SearchInfo si)</code>. This utility
		119	method returns <code>Iterator</code> of <code>FileObject</code>s
		120	for the provided <code>SearchInfo</code>. This change simplifies
		121	the work with <code>SearchInfo</code> implementations.
		122	</p>
		123	</description>
		124	<class package="org.openidex.search" name="Utils"/>
		125	</change>
		126
		127	<change id="SearchInfo.Files">
		128	<api name="search"/>
		129	<summary>Added interface <code>SearchInfo.Files</code></summary>
		130	<version major="3" minor="20"/>
		131	<date day="13" month="1" year="2009"/>
		132	<author login="kaktus"/>
		133	<compatibility addition="yes"/>
		134	<description>
		135	<p>
		136	Added <code>SearchInfo.Files</code> interface which extends
		137	<code>SearchInfo</code> interface. It adds method
		138	<code>filesToSearch()</code> to provide <code>FileObject</code>s
		139	which should be searched. This change allows to operate <code>FileObject</code>s
		140	in the search mechanism instead of <code>DataObject</code>s and
		141	as a result improves search performance.
		142	</p>
		143	</description>
		144	<class package="org.openidex.search" name="SearchInfo.Files"/>
		145	<issue number="134558"/>
		146	</change>
107		147
108		148
109	<change id="SearchInfoFactory.createCompoundSearchInfo">	149	<change id="SearchInfoFactory.createCompoundSearchInfo">

Lines 48-63 Link Here

(-)a/o.openidex.util/src/org/openidex/search/SimpleSearchIterator.java (-12 / +10 lines)
48	import java.util.NoSuchElementException;	48	import java.util.NoSuchElementException;
49	import org.openide.filesystems.FileObject;	49	import org.openide.filesystems.FileObject;
50	import org.openide.loaders.DataFolder;	50	import org.openide.loaders.DataFolder;
51	import org.openide.loaders.DataObject;
52		51
53	/**	52	/**
54	*	53	*
55	* @author Marian Petras	54	* @author Marian Petras
56	*/	55	*/
57	class SimpleSearchIterator implements Iterator<DataObject> {	56	class SimpleSearchIterator implements Iterator<FileObject> {
58		57
59	/** current enumeration of children */	58	/** current enumeration of children */
60	private Enumeration<DataObject> childrenEnum;	59	private Enumeration<? extends FileObject> childrenEnum;
61	/**	60	/**
62	* filters to be applied on the current enumeration of children	61	* filters to be applied on the current enumeration of children
63	* ({@link #childrenEnum})	62	* ({@link #childrenEnum})
Lines 70-77 Link Here
70	/** */	69	/** */
71	private final boolean recursive;	70	private final boolean recursive;
72	/** stack of the ancestor folders' children enumerations */	71	/** stack of the ancestor folders' children enumerations */
73	private final List<Enumeration<DataObject>> enums	72	private final List<Enumeration<? extends FileObject>> enums
74	= new ArrayList<Enumeration<DataObject>>(); //unsynced stack	73	= new ArrayList<Enumeration<? extends FileObject>>(); //unsynced stack
75	/**	74	/**
76	* stack of filter lists to be applied on children of the ancestor folders	75	* stack of filter lists to be applied on children of the ancestor folders
77	* ({@link #enums})	76	* ({@link #enums})
Lines 84-97 Link Here
84	* <code>DataObject</code> to be returned the next time method	83	* <code>DataObject</code> to be returned the next time method
85	* {@link #next()} is called	84	* {@link #next()} is called
86	*/	85	*/
87	private DataObject nextObject;	86	private FileObject nextObject;
88		87
89	/**	88	/**
90	*/	89	*/
91	SimpleSearchIterator(DataFolder folder,	90	SimpleSearchIterator(DataFolder folder,
92	boolean recursive,	91	boolean recursive,
93	List<FileObjectFilter> filters) {	92	List<FileObjectFilter> filters) {
94	this.childrenEnum = folder.children(false);	93	this.childrenEnum = folder.getPrimaryFile().getChildren(false);
95	this.recursive = recursive;	94	this.recursive = recursive;
96	this.filters = (filters != null) ? new ArrayList<FileObjectFilter>(filters)	95	this.filters = (filters != null) ? new ArrayList<FileObjectFilter>(filters)
97	: null;	96	: null;
Lines 108-114 Link Here
108		107
109	/**	108	/**
110	*/	109	*/
111	public DataObject next() {	110	public FileObject next() {
112	if (!hasNext()) {	111	if (!hasNext()) {
113	throw new NoSuchElementException();	112	throw new NoSuchElementException();
114	}	113	}
Lines 124-131 Link Here
124	assert childrenEnum != null;	123	assert childrenEnum != null;
125	do {	124	do {
126	if (childrenEnum.hasMoreElements()) {	125	if (childrenEnum.hasMoreElements()) {
127	DataObject dataObject = childrenEnum.nextElement();	126	FileObject file = childrenEnum.nextElement();
128	FileObject file = dataObject.getPrimaryFile();
129	if (file.isFolder()) {	127	if (file.isFolder()) {
130	if (!recursive) {	128	if (!recursive) {
131	continue;	129	continue;
Lines 147-159 Link Here
147	filterLists.add(null);	145	filterLists.add(null);
148	}	146	}
149	enums.add(childrenEnum);	147	enums.add(childrenEnum);
150	childrenEnum = ((DataFolder) dataObject).children(false);	148	childrenEnum = file.getChildren(false);
151	} else {	149	} else {
152	if ((filters != null) && !checkFileFilters(file)) {	150	if ((filters != null) && !checkFileFilters(file)) {
153	continue;	151	continue;
154	}	152	}
155		153
156	nextObject = dataObject;	154	nextObject = file;
157	break;	155	break;
158	}	156	}
159	} else {	157	} else {

Lines 42-48 Link Here

(-)a/o.openidex.util/test/unit/src/org/openidex/search/CompoundSearchInfoTest.java (-59 / +180 lines)
42	package org.openidex.search;	42	package org.openidex.search;
43		43
44	import java.io.IOException;	44	import java.io.IOException;
		45	import java.util.HashSet;
45	import java.util.Iterator;	46	import java.util.Iterator;
		47	import java.util.Set;
46	import org.netbeans.junit.MockServices;	48	import org.netbeans.junit.MockServices;
47	import org.netbeans.junit.NbTestCase;	49	import org.netbeans.junit.NbTestCase;
48	import org.openide.filesystems.FileObject;	50	import org.openide.filesystems.FileObject;
Lines 80-88 Link Here
80	}	82	}
81		83
82	public void testEmptyList() {	84	public void testEmptyList() {
83	SearchInfo searchInfo = new CompoundSearchInfo(new SearchInfo[0]);	85	SearchInfo.Files searchInfo = new CompoundSearchInfo(new SearchInfo[0]);
84	assertFalse(searchInfo.canSearch());	86	assertFalse(searchInfo.canSearch());
85	assertFalse(searchInfo.objectsToSearch().hasNext());	87	assertFalse(searchInfo.objectsToSearch().hasNext());
		88	assertFalse(searchInfo.filesToSearch().hasNext());
86	}	89	}
87		90
88	public void testOneItemList() throws IOException {	91	public void testOneItemList() throws IOException {
Lines 95-141 Link Here
95	dir.createData("c", DummyDataLoader.dummyExt);	98	dir.createData("c", DummyDataLoader.dummyExt);
96	DataFolder folder = DataFolder.findFolder(dir);	99	DataFolder folder = DataFolder.findFolder(dir);
97		100
98
99	SearchInfo refSearchInfo;	101	SearchInfo refSearchInfo;
100	SearchInfo testSearchInfo;	102	SearchInfo testSearchInfo;
101	boolean refCanSearch;
102	boolean testCanSearch;
103	Iterator refIt;	103	Iterator refIt;
104	Iterator testIt;	104	Iterator testIt;
105	int testIterationsCount;	105	Set testSet = new HashSet();
106
107		106
108	refSearchInfo = new SimpleSearchInfo(folder, false, null);	107	refSearchInfo = new SimpleSearchInfo(folder, false, null);
109	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});	108	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
110	assertTrue(testSearchInfo.canSearch());	109	assertTrue(testSearchInfo.canSearch());
111		110
		111	for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
		112	testSet.add(testIt.next());
		113	}
112	refIt = refSearchInfo.objectsToSearch();	114	refIt = refSearchInfo.objectsToSearch();
113	testIt = testSearchInfo.objectsToSearch();	115	while (refIt.hasNext()) {
114	for (testIterationsCount = 0;;testIterationsCount++) {	116	assertTrue(testSet.remove(refIt.next()));
115	boolean refHasNext = refIt.hasNext();	117	}
116	boolean testHasNext = testIt.hasNext();	118	assertTrue(testSet.isEmpty());
117	assertEquals(refHasNext, testHasNext);
118		119
119	if (!refHasNext) {
120	break;
121	}
122
123	Object refObj = refIt.next();
124	Object testObj = testIt.next();
125	assertSame(refObj, testObj);
126	}
127	assertEquals(3, testIterationsCount);
128
129
130	refSearchInfo = new SimpleSearchInfo(folder, false, null) {	120	refSearchInfo = new SimpleSearchInfo(folder, false, null) {
131	public boolean canSearch() {	121	public boolean canSearch() {
132	return false;	122	return false;
133	}	123	}
134	};	124	};
135	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});	125	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
136	refCanSearch = refSearchInfo.canSearch();	126	assertEquals(refSearchInfo.canSearch(), testSearchInfo.canSearch());
137	testCanSearch = testSearchInfo.canSearch();	127	}
138	assertEquals(refCanSearch, testCanSearch);	128
		129	public void testOneItemFilesList() throws IOException {
		130	FileSystem fs = FileUtil.createMemoryFileSystem();
		131	FileObject fsRoot = fs.getRoot();
		132
		133	FileObject dir = fsRoot.createFolder("dir");
		134	dir.createData("a", DummyDataLoader.dummyExt);
		135	dir.createData("b", DummyDataLoader.dummyExt);
		136	dir.createData("c", DummyDataLoader.dummyExt);
		137	DataFolder folder = DataFolder.findFolder(dir);
		138
		139	SearchInfo.Files refSearchInfo;
		140	SearchInfo.Files testSearchInfo;
		141	Iterator refIt;
		142	Iterator testIt;
		143	Set testSet = new HashSet();
		144
		145	refSearchInfo = new SimpleSearchInfo(folder, false, null);
		146	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
		147	assertTrue(testSearchInfo.canSearch());
		148
		149	for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
		150	testSet.add(testIt.next());
		151	}
		152	refIt = refSearchInfo.filesToSearch();
		153	while (refIt.hasNext()) {
		154	assertTrue(testSet.remove(refIt.next()));
		155	}
		156	assertTrue(testSet.isEmpty());
		157
		158	refSearchInfo = new SimpleSearchInfo(folder, false, null) {
		159	public boolean canSearch() {
		160	return false;
		161	}
		162	};
		163	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo});
		164	assertEquals(refSearchInfo.canSearch(), testSearchInfo.canSearch());
139	}	165	}
140		166
141	public void testMultipleItemsList() throws IOException {	167	public void testMultipleItemsList() throws IOException {
Lines 158-191 Link Here
158	SearchInfo testSearchInfo;	184	SearchInfo testSearchInfo;
159	Iterator refIt;	185	Iterator refIt;
160	Iterator testIt;	186	Iterator testIt;
161	int testIterationsCount;
162
163		187
164	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);	188	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
165	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);	189	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);
166	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,	190	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
167	refSearchInfo2});	191	refSearchInfo2});
168	assertTrue(testSearchInfo.canSearch());	192	assertTrue(testSearchInfo.canSearch());
169		193
170	testIterationsCount = 0;	194	Set testSet = new HashSet();
171	testIt = testSearchInfo.objectsToSearch();	195	for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
		196	testSet.add(testIt.next());
		197	}
		198
172	refIt = refSearchInfo1.objectsToSearch();	199	refIt = refSearchInfo1.objectsToSearch();
173	while (refIt.hasNext()) {	200	while (refIt.hasNext()) {
174	assertTrue(testIt.hasNext());	201	assertTrue(testSet.remove(refIt.next()));
175	assertSame(refIt.next(), testIt.next());
176	testIterationsCount++;
177	}	202	}
178	assertTrue(testIt.hasNext());
179	refIt = refSearchInfo2.objectsToSearch();	203	refIt = refSearchInfo2.objectsToSearch();
180	while (refIt.hasNext()) {	204	while (refIt.hasNext()) {
181	assertTrue(testIt.hasNext());	205	assertTrue(testSet.remove(refIt.next()));
182	assertSame(refIt.next(), testIt.next());
183	testIterationsCount++;
184	}	206	}
185	assertFalse(testIt.hasNext());	207	assertTrue(testSet.isEmpty());
186	assertEquals(5, testIterationsCount);	208
187		209
188
189	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);	210	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
190	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {	211	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {
191	public boolean canSearch() {	212	public boolean canSearch() {
Lines 195-212 Link Here
195	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,	216	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
196	refSearchInfo2});	217	refSearchInfo2});
197	assertTrue(testSearchInfo.canSearch());	218	assertTrue(testSearchInfo.canSearch());
198		219
199	testIterationsCount = 0;	220	testSet.clear();
200	testIt = testSearchInfo.objectsToSearch();	221	for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
		222	testSet.add(testIt.next());
		223	}
		224
201	refIt = refSearchInfo1.objectsToSearch();	225	refIt = refSearchInfo1.objectsToSearch();
202	while (refIt.hasNext()) {	226	while (refIt.hasNext()) {
203	assertTrue(testIt.hasNext());	227	assertTrue(testSet.remove(refIt.next()));
204	assertSame(refIt.next(), testIt.next());
205	testIterationsCount++;
206	}	228	}
207	assertFalse(testIt.hasNext());	229	assertTrue(testSet.isEmpty());
208	assertEquals(3, testIterationsCount);	230
209
210		231
211	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {	232	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
212	public boolean canSearch() {	233	public boolean canSearch() {
Lines 218-233 Link Here
218	refSearchInfo2});	239	refSearchInfo2});
219	assertTrue(testSearchInfo.canSearch());	240	assertTrue(testSearchInfo.canSearch());
220		241
221	testIterationsCount = 0;	242	testSet.clear();
222	testIt = testSearchInfo.objectsToSearch();	243	for(testIt = testSearchInfo.objectsToSearch(); testIt.hasNext();){
		244	testSet.add(testIt.next());
		245	}
223	refIt = refSearchInfo2.objectsToSearch();	246	refIt = refSearchInfo2.objectsToSearch();
224	while (refIt.hasNext()) {	247	while (refIt.hasNext()) {
225	assertTrue(testIt.hasNext());	248	assertTrue(testSet.remove(refIt.next()));
226	assertSame(refIt.next(), testIt.next());
227	testIterationsCount++;
228	}	249	}
229	assertFalse(testIt.hasNext());	250	assertTrue(testSet.isEmpty());
230	assertEquals(2, testIterationsCount);
231		251
232		252
233	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {	253	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
Lines 244-248 Link Here
244	refSearchInfo2});	264	refSearchInfo2});
245	assertFalse(testSearchInfo.canSearch());	265	assertFalse(testSearchInfo.canSearch());
246	}	266	}
247		267
		268	public void testMultipleItemsFilesList() throws IOException {
		269	FileSystem fs = FileUtil.createMemoryFileSystem();
		270	FileObject fsRoot = fs.getRoot();
		271
		272	FileObject dir1 = fsRoot.createFolder("dir1");
		273	dir1.createData("1a", DummyDataLoader.dummyExt);
		274	dir1.createData("1b", DummyDataLoader.dummyExt);
		275	dir1.createData("1c", DummyDataLoader.dummyExt);
		276	DataFolder folder1 = DataFolder.findFolder(dir1);
		277
		278	FileObject dir2 = fsRoot.createFolder("dir2");
		279	dir2.createData("2a", DummyDataLoader.dummyExt);
		280	dir2.createData("2b", DummyDataLoader.dummyExt);
		281	DataFolder folder2 = DataFolder.findFolder(dir2);
		282
		283
		284	SearchInfo.Files refSearchInfo1, refSearchInfo2;
		285	SearchInfo.Files testSearchInfo;
		286	Iterator refIt;
		287	Iterator testIt;
		288
		289	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
		290	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);
		291	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
		292	refSearchInfo2});
		293	assertTrue(testSearchInfo.canSearch());
		294
		295	Set testSet = new HashSet();
		296	for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
		297	testSet.add(testIt.next());
		298	}
		299
		300	refIt = refSearchInfo1.filesToSearch();
		301	while (refIt.hasNext()) {
		302	assertTrue(testSet.remove(refIt.next()));
		303	}
		304	refIt = refSearchInfo2.filesToSearch();
		305	while (refIt.hasNext()) {
		306	assertTrue(testSet.remove(refIt.next()));
		307	}
		308	assertTrue(testSet.isEmpty());
		309
		310
		311	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null);
		312	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {
		313	public boolean canSearch() {
		314	return false;
		315	}
		316	};
		317	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
		318	refSearchInfo2});
		319	assertTrue(testSearchInfo.canSearch());
		320
		321	testSet.clear();
		322	for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
		323	testSet.add(testIt.next());
		324	}
		325
		326	refIt = refSearchInfo1.filesToSearch();
		327	while (refIt.hasNext()) {
		328	assertTrue(testSet.remove(refIt.next()));
		329	}
		330	assertTrue(testSet.isEmpty());
		331
332
333	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
334	public boolean canSearch() {
335	return false;
336	}
337	};
338	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null);
339	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
340	refSearchInfo2});
341	assertTrue(testSearchInfo.canSearch());
342
343	testSet.clear();
344	for(testIt = testSearchInfo.filesToSearch(); testIt.hasNext();){
345	testSet.add(testIt.next());
346	}
347	refIt = refSearchInfo2.filesToSearch();
348	while (refIt.hasNext()) {
349	assertTrue(testSet.remove(refIt.next()));
350	}
351	assertTrue(testSet.isEmpty());
352
353
354	refSearchInfo1 = new SimpleSearchInfo(folder1, false, null) {
355	public boolean canSearch() {
356	return false;
357	}
358	};
359	refSearchInfo2 = new SimpleSearchInfo(folder2, false, null) {
360	public boolean canSearch() {
361	return false;
362	}
363	};
364	testSearchInfo = new CompoundSearchInfo(new SearchInfo[] {refSearchInfo1,
365	refSearchInfo2});
366	assertFalse(testSearchInfo.canSearch());
367	}
368
248	}	369	}