Attachment #75268 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 1-5 Link Here

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

/**

     */
    public Iterator<DataObject> objectsToSearch();
    
    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();
}
}




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

    /**
     * Empty search info object.

     * (returned by method
     * {@link SearchInfo#objectsToSearch objectsToSearch()}) has no elements.
     */
    static final SearchInfo.Files EMPTY_SEARCH_INFO
        = new SearchInfo.Files() {
            public boolean canSearch() {
                return true;
            }
            public Iterator<DataObject> objectsToSearch() {
                return Collections.<DataObject>emptyList().iterator();
            }

            public Iterator<FileObject> filesToSearch() {
                return Collections.<FileObject>emptyList().iterator();
            }
        };
        
    /** */

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

    /**
     */
    public Iterator<FileObject> filesToSearch() {
        return new SimpleSearchIterator(rootFolder,
                                        recursive,
                                        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

(-)o.openidex.util/src/org/openidex/search/SubnodesSearchInfo.java (-7 / +14 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-107 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 Collections.<FileObject>emptyList().iterator();
86	}	93	}
87		94
88	List<SearchInfo> searchInfoElements = new ArrayList<SearchInfo>(nodes.length);	95	List<SearchInfo.Files> searchInfoElements = new ArrayList<SearchInfo.Files>(nodes.length);
89	for (int i = 0; i < nodes.length; i++) {	96	for (int i = 0; i < nodes.length; i++) {
90	SearchInfo subInfo = Utils.getSearchInfo(nodes[i]);	97	SearchInfo subInfo = Utils.getSearchInfo(nodes[i]);
91	if (subInfo != null && subInfo.canSearch()) {	98	if (subInfo != null && subInfo.canSearch()) {
92	searchInfoElements.add(subInfo);	99	searchInfoElements.add((SearchInfo.Files)subInfo);
93	}	100	}
94	}	101	}
95		102
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 searchInfoElements.get(0).filesToSearch();
102	default:	109	default:
103	return new CompoundSearchIterator(	110	return new CompoundSearchIterator(
104	searchInfoElements.toArray(new SearchInfo[size]));	111	searchInfoElements.toArray(new SearchInfo.Files[size]));
105	}	112	}
106	}	113	}
107		114

Lines 41-54 Link Here

(-)o.openidex.util/src/org/openidex/search/Utils.java (-1 / +31 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;
		52	import org.openide.util.Exceptions;
46		53
47	/**	54	/**
48	*	55	*
49	* @author Marian Petras	56	* @author Marian Petras
		57	* @author kaktus
50	*/	58	*/
51	final class Utils {	59	public final class Utils {
52		60
53	/**	61	/**
54	*/	62	*/
Lines 72-75 Link Here
72	}	80	}
73	}	81	}
74		82
		83	public static Iterator<FileObject> getFileObjectsIterator(SearchInfo si){
		84	if (si instanceof SearchInfo.Files){
		85	return ((SearchInfo.Files)si).filesToSearch();
		86	}else{
		87	Set<FileObject> set = new HashSet<FileObject>();
		88	for(Iterator<DataObject> iter = si.objectsToSearch(); iter.hasNext();){
		89	set.add(iter.next().getPrimaryFile());
75	}	90	}
		91	return set.iterator();
		92	}
		93	}
		94
		95	static Iterator<DataObject> toDataObjectIterator(Iterator<FileObject> itFO){
		96	Set<DataObject> set = new HashSet<DataObject>();
		97	while(itFO.hasNext()){
		98	try {
		99	set.add(DataObject.find(itFO.next()));
		100	} catch (DataObjectNotFoundException ex){}
		101	}
		102	return set.iterator();
		103	}
		104
		105	}

Lines 183-189 Link Here

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

(-)utilities/src/org/netbeans/modules/search/BasicSearchCriteria.java (-6 / +11 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 639-648 Link Here
639	* @return {@code true} if the file contains at least one substring	642	* @return {@code true} if the file contains at least one substring
640	* matching the pattern, {@code false} otherwise	643	* matching the pattern, {@code false} otherwise
641	*/	644	*/
642	private boolean checkFileContent(FileObject fileObj, DataObject dataObj) {	645	private boolean checkFileContent(FileObject fileObj) {
643	boolean firstMatch = true;	646	boolean firstMatch = true;
644	SearchPattern searchPattern = null;	647	SearchPattern searchPattern = null;
645	ArrayList<TextDetail> txtDetails = null;	648	ArrayList<TextDetail> txtDetails = null;
		649	DataObject dObj = null;
646		650
647	LineNumberReader reader = null;	651	LineNumberReader reader = null;
648	try {	652	try {
Lines 656-663 Link Here
656	searchPattern = createSearchPattern();	660	searchPattern = createSearchPattern();
657	txtDetails = new ArrayList<TextDetail>(5);	661	txtDetails = new ArrayList<TextDetail>(5);
658	firstMatch = false;	662	firstMatch = false;
		663	dObj = DataObject.find(fileObj);
659	}	664	}
660	TextDetail det = new TextDetail(dataObj, searchPattern);	665	TextDetail det = new TextDetail(dObj, searchPattern);
661	det.setLine(reader.getLineNumber());	666	det.setLine(reader.getLineNumber());
662	det.setLineText(line);	667	det.setLineText(line);
663	int start = matcher.start();	668	int start = matcher.start();
Lines 669-675 Link Here
669	}	674	}
670	if (txtDetails != null) {	675	if (txtDetails != null) {
671	txtDetails.trimToSize();	676	txtDetails.trimToSize();
672	getDetailsMap().put(dataObj, txtDetails);	677	getDetailsMap().put(dObj, txtDetails);
673	return true;	678	return true;
674	} else {	679	} else {
675	return false;	680	return false;

Lines 44-58 Link Here

(-)utilities/src/org/netbeans/modules/search/SpecialSearchGroup.java (-3 / +29 lines)
44	import java.nio.charset.Charset;	44	import java.nio.charset.Charset;
45	import java.util.Collection;	45	import java.util.Collection;
46	import java.util.Iterator;	46	import java.util.Iterator;
		47	import org.openide.filesystems.FileObject;
47	import org.openide.loaders.DataObject;	48	import org.openide.loaders.DataObject;
48	import org.openidex.search.DataObjectSearchGroup;	49	import org.openide.loaders.DataObjectNotFoundException;
		50	import org.openide.util.Exceptions;
		51	import org.openidex.search.FileObjectSearchGroup;
		52	import org.openidex.search.SearchInfo;
49	import org.openidex.search.SearchType;	53	import org.openidex.search.SearchType;
50		54
51	/**	55	/**
52	*	56	*
53	* @author Marian Petras	57	* @author Marian Petras
		58	* @author kaktus
54	*/	59	*/
55	final class SpecialSearchGroup extends DataObjectSearchGroup {	60	final class SpecialSearchGroup extends FileObjectSearchGroup {
56		61
57	final BasicSearchCriteria basicCriteria;	62	final BasicSearchCriteria basicCriteria;
58	final boolean hasExtraSearchTypes;	63	final boolean hasExtraSearchTypes;
Lines 81-93 Link Here
81		86
82	@Override	87	@Override
83	public void doSearch() {	88	public void doSearch() {
84	for (Iterator j = searchScope.getSearchInfo().objectsToSearch(); j.hasNext(); ) {	89	SearchInfo sInfo = searchScope.getSearchInfo();
		90	if (sInfo instanceof SearchInfo.Files){
		91	for (Iterator j = ((SearchInfo.Files)sInfo).filesToSearch(); j.hasNext(); ) {
85	if (stopped) {	92	if (stopped) {
86	return;	93	return;
87	}	94	}
		95	processSearchObject(/FileObject/ j.next());
		96	}
		97	}else{
		98	for (Iterator j = sInfo.objectsToSearch(); j.hasNext(); ) {
		99	if (stopped) {
		100	return;
		101	}
88	processSearchObject(/DataObject/ j.next());	102	processSearchObject(/DataObject/ j.next());
89	}	103	}
90	}	104	}
		105	}
91		106
92	/**	107	/**
93	* Provides search on one search object instance. The object is added to	108	* Provides search on one search object instance. The object is added to
Lines 104-113 Link Here
104	protected void processSearchObject(Object searchObject) {	119	protected void processSearchObject(Object searchObject) {
105	if (!hasExtraSearchTypes) {	120	if (!hasExtraSearchTypes) {
106	assert basicCriteria != null;	121	assert basicCriteria != null;
		122	if (searchObject instanceof DataObject){
107	DataObject dataObj = (DataObject) searchObject;	123	DataObject dataObj = (DataObject) searchObject;
108	if (basicCriteria.matches(dataObj)) {	124	if (basicCriteria.matches(dataObj)) {
109	notifyMatchingObjectFound(dataObj);	125	notifyMatchingObjectFound(dataObj);
110	}	126	}
		127	} else if (searchObject instanceof FileObject){
		128	FileObject fileObj = (FileObject) searchObject;
		129	if (basicCriteria.matches(fileObj)) {
		130	try {
		131	notifyMatchingObjectFound(DataObject.find(fileObj));
		132	} catch (DataObjectNotFoundException ex) {
		133	Exceptions.printStackTrace(ex);
		134	}
		135	}
		136	}
111	return;	137	return;
112	}	138	}
113		139

Return to bug 134558

Lines 48-63 Link Here

(-)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 {