Attachment #105591 for bug #194326

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





package org.netbeans.modules.search;

import java.io.InputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileInputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;

import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.queries.FileEncodingQuery;
import org.netbeans.modules.search.TextDetail.DetailNode;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;

        lastCharset = FileEncodingQuery.getEncoding(fo);
        SearchPattern sp = createSearchPattern();
        BufferedCharSequence bcs = null;
        try {         
            InputStream stream = fo.getInputStream();
            bcs = new BufferedCharSequence(stream, lastCharset, fo.getSize());
            ArrayList<TextDetail> txtDetails = getTextDetails(bcs, fo, sp);
            if (txtDetails.isEmpty()){                
                return false;
            }            
            getDetailsMap().put(fo, txtDetails);
            freeDataObject();
            return true;





package org.netbeans.modules.search;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.nio.cs.ThreadLocalCoders;



    /**
     * Creates {@code BufferedCharSequence} for the specified {@code stream}.
     * @param stream is a stream that will be buffered and represented as a
     *        {@code CharSequence}.
     * @param charset is a named mapping that will be used to decode a sequence
     *                of bytes from the {@code stream}.
     * @param size is the size of the file.
     */
    public BufferedCharSequence(final InputStream stream, Charset charset, long size) {
        this(stream.getChannel(), charset);
    }

    /**
     * Creates {@code BufferedCharSequence} for the specified {@code channel}.
     * @param channel is a channel that will be buffered and represented as a
     *        {@code CharSequence}.
     * @param charset is a named mapping that will be used to decode a sequence
     *                of bytes from the {@code channel}.
     */
    public BufferedCharSequence(final FileChannel channel, Charset charset) {
        // TODO charset.name() is used instead of charset due to a bug in the
        // org.netbeans.api.queries.FileEncodingQuery.ProxyCharset.ProxyDecoder
        // The IllegalStateException may be thrown after correct actions.
        // See #169804
        this(stream,
            ThreadLocalCoders.decoderFor(charset.name())
                             .onMalformedInput(CodingErrorAction.REPLACE)
                             .onUnmappableCharacter(CodingErrorAction.REPLACE), size);
    }


    public BufferedCharSequence(final InputStream stream,
                                CharsetDecoder decoder, long size) {
        this.source = new Source(stream, size);
     * @param decoder is a decoder that will be used to decode a sequence
     *                of bytes from the {@code channel}.
     */
    public BufferedCharSequence(final FileChannel channel,
                                CharsetDecoder decoder) {
        this.source = new Source(channel);
        this.decoder = decoder;
        this.sink = new Sink(this.source);
        LOG.finer("<init> " + this.source + "; decoder = " + this.decoder +

     * @return the underlying instance of this class.
     * @throws SourceIOException
     */
    public BufferedCharSequence reset() throws SourceIOException {        
        source.reset();
        sink.reset();
        decoder.reset();

        reset();
        int length = 0;
        while(sink.next()) {  }
        length = sink.buffer.scope.end;        
        return length;
    }


     */
    public String getLineText(int start) {
        int oldPosition = changePosition(start);
        String text = nextLineText();        
        changePosition(oldPosition);
        return text;
    }

    private char getCharAt(int index) throws IndexOutOfBoundsException {        
        if(sink.buffer.scope.isBefore(index)) {            
            reset();
        }
        while(!sink.buffer.scope.isInside(index)) {

                throw new IndexOutOfBoundsException("index is " +
                        index + " > lenght"); // NOI18N
            }
        }        
        return sink.charAt(index);
    }


    /**
     * The source buffer.
     */
       private class Source {
        private int maxBufferSize = MAX_SOURCE_BUFFER_SIZE;

        private ByteBuffer buffer;
        private BufferedInputStream bstream;
        private int bufferSize;
        
        public Source(InputStream inputStream, long bufferSize) {
            this.bstream = new BufferedInputStream(inputStream);
            this.bstream.mark(Integer.MAX_VALUE);
            this.bufferSize = getBufferSize(bufferSize);
            buffer = newBuffer();
        }

        @Override
        public String toString() {
            return "source=[stream = " + bstream.toString() + ", buffer = " + buffer + "]";
        }

        private ByteBuffer newBuffer() {
            return ByteBuffer.allocate(bufferSize);
        }

       public void reset() {        
            try {                
                bstream.reset();
            } catch (IOException ex) {
                throw new SourceIOException(ex);
            }            
            buffer.clear();
        }

        /**
         * Reads a sequence of bytes from the source stream. Bytes are read
         * starting at the stream's current position, and then the
         * position is updated with the number of bytes actually read.
         *
         * @return The number of bytes read, possibly zero, or -1 if 
         * the end-of-stream is reached
         *
         * @throws ProcessException If some other I/O error occurs
         */
        private int read() {
            try {
                if(buffer.hasArray()) {
                    int res = bstream.read(buffer.array());
                    if(res > 0) {
                        buffer.position(res);
                    }
                    return res;
                }
                throw new IOException("No byte array");
            } catch (IOException ex) {
                throw new SourceIOException(ex);
            }
        }

        public void close() throws IOException {
            bstream.close();
        }

        public int getSize(long size) {
            channel.close();
        }

        public int size() {
            try {
                return getSize(channel.size());
            } catch (IOException ioe) {
                throw new SourceIOException(ioe);
            }
        }

        private int getSize(long size) {
            if (size > Integer.MAX_VALUE) {
                LOG.warning("File size is " + size + "bytes. " +
                            "Only first " + MAX_FILE_SIZE +

            return (int) size;
        }

        private int getBufferSize(long bufferSize) {
            int size = Math.min(getSize(bufferSize), maxBufferSize);
            return size;
        }


         *
         * @return {@code true} if EOF, otherwise {@code false}.
         */
        public boolean readNext() {           
            buffer.clear();            
            int status = read();            
            buffer.flip();            
            return status == -1;
        }


            return "sink = [" + buffer + "]";
        }

        public void reset() {            
            buffer.reset();
        }


         * @return {@code true} is successful, otherwise {@code false}.
         */
        private boolean next() {
            CharBuffer out = buffer.clear();           
            boolean endOfInput = false;
            if(coderResult == CoderResult.UNDERFLOW) {
                endOfInput = source.readNext();

            while((coderResult =
                    decoder.decode(source.buffer, out, endOfInput))
                    != CoderResult.UNDERFLOW) {
                out = buffer.growBuffer();                
            }
            if(endOfInput) {
                while((coderResult = decoder.flush(out))

                return c;
            }

            private void reset() {               
                scope.reset();
                charBuffer.clear();
            }

                return charBuffer;
            }

            private void adjustScope() {             
                scope.start = scope.end == -1 ? 0 : scope.end;              
                flip();                                                 
                scope.end = scope.start + charBuffer.limit();                              
            }

            /**

Lines 313-319 Link Here

(-)a/utilities/src/org/netbeans/modules/search/ContextView.java (-1 / +1 lines)
313	= matchingObj.checkValidity();	313	= matchingObj.checkValidity();
314	if (invalidityStatus != null) {	314	if (invalidityStatus != null) {
315	displayMessage(invalidityStatus.getDescription(	315	displayMessage(invalidityStatus.getDescription(
316	matchingObj.getFile().getPath()));	316	matchingObj.getFileObject().getPath()));
317	return;	317	return;
318	}	318	}
319		319





package org.netbeans.modules.search;

import org.openide.util.Exceptions;
import java.awt.EventQueue;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

import java.util.regex.Matcher;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.util.NbBundle;
import static java.util.logging.Level.FINER;

    /** */
    private final ResultModel resultModel;
    /** */
    private final FileObject fileObject;
    /** */
    private final long timestamp;
    

    /** */
    private boolean valid = true;
    /** */
    private String text;
    
    /**
     * Creates a new {@code MatchingObject} with a reference to the found

        this.object = object;
        this.charset = charset;
        
        fileObject = fileObject();
        timestamp =  fileObject.lastModified().getTime();        
        timestamp = (file != null) ? file.lastModified() : 0L;
        valid = (timestamp != 0L);
        
        setUpDataObjValidityChecking();

        return valid && data != null ? data.isValid() : false; // #190819
    }
    
    private FileObject fileObject() {
        return object instanceof FileObject ?
            (FileObject) object :
            ((DataObject) getDataObject()).getPrimaryFile();
    }

    /**
     */
    FileObject getFileObject() {
        return fileObject;
    }
    
    /**
     */

        return expanded;
    }
    
    /**
     */
    File getFile() {
        return file;
    }
    
    /** Get the name (not the path) of the file */
    String getName() {        
        return getFileObject().getName();
    }

    String getHtmlDisplayName() {

    
    /**
     */
    String getDescription() { 
        return getFileObject().getParent().getPath();
    }

    /**
     */
    String getText() throws IOException {
        return text(false);
        if (txt != null) {
            return txt.toString();
        } else {
            return null;
        }
    }

    /**

     * @author  TimBoudreau
     * @author  Marian Petras
     */
 
    private String text(boolean refreshCache) throws IOException {
    }
    
    private StringBuilder text(boolean refreshCache) throws IOException {
        assert !EventQueue.isDispatchThread();
        
        if (refreshCache || (text == null)) {     
            text = getFileObject().asText();
        }
        return text;
    }

    @Override

            }
            throw new IOException("Unknown object in search: " +
                                  object);// NOI18N
        } catch (IOException ex) {       
            valid = false;
            return null;
        }

        
        InvalidityStatus status = getInvalidityStatus();
        if (status != null) {
            descr = status.getDescription(getFileObject().getPath());
        } else {
            descr = null;
        }

     */
    private InvalidityStatus getInvalidityStatus() {
        log(FINER, "getInvalidityStatus()");                            //NOI18N
        FileObject f = getFileObject();
        if (!f.isValid()) {
            log(FINEST, " - DELETED");            
            return InvalidityStatus.DELETED;
        }
        if (f.isFolder()) {
            log(FINEST, " - BECAME_DIR");            
            log(FINEST, " - BECAME_DIR");
            return InvalidityStatus.BECAME_DIR;
        }
        
        long stamp = f.lastModified().getTime();
        if (stamp > resultModel.getCreationTime()) {
            log(SEVERE, "file's timestamp changed since start of the search");
            if (LOG.isLoggable(FINEST)) {

                log(FINEST, " - file stamp:           " + stamp + " (" + cal.getTime() + ')');
                cal.setTimeInMillis(resultModel.getCreationTime());
                log(FINEST, " - result model created: " + resultModel.getCreationTime() + " (" + cal.getTime() + ')');
            }            
            return InvalidityStatus.CHANGED;
        }
        
        if (f.getSize() > Integer.MAX_VALUE) {            
            return InvalidityStatus.TOO_BIG;
        }
        
        if (!f.canRead()) {           
            return InvalidityStatus.CANT_READ;
        }
        

        if (shouldReplaceNone) {
            return null;
        }
       
        StringBuilder content = new StringBuilder(text(true));   //refresh the cache, reads the file
        
        List<TextDetail> textMatches = 
                resultModel.basicCriteria.getTextDetails(getFileObject());

            throw new IllegalStateException("Buffer is gone");          //NOI18N
        }
        
        if (REALLY_WRITE) {            
            final FileObject fileObject = getFileObject();
            Writer writer = null;
            try {
                writer = new OutputStreamWriter(

                }
            }
        } else {
            System.err.println("Would write to " + getFileObject().getPath());//NOI18N
            System.err.println(text);
        }
    }

    /**
     */
    private String makeStringToWrite() {
        return text;
    }
    
    /**

            return false;
        }
        final MatchingObject other = (MatchingObject) obj;
        if (this.fileObject != other.fileObject && (this.fileObject == null || !this.fileObject.equals(other.fileObject))) {
            return false;
        }
        return true;

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 73 * hash + (this.fileObject != null ? this.fileObject.hashCode() : 0);
        return hash;
    }


Lines 56-61 Link Here

(-)a/utilities/src/org/netbeans/modules/search/NodeListener.java (-1 / +7 lines)
56	import java.awt.event.KeyListener;	56	import java.awt.event.KeyListener;
57	import java.awt.event.MouseEvent;	57	import java.awt.event.MouseEvent;
58	import java.awt.event.MouseListener;	58	import java.awt.event.MouseListener;
		59	import java.io.File;
59	import java.io.IOException;	60	import java.io.IOException;
60	import java.util.ArrayList;	61	import java.util.ArrayList;
61	import java.util.Collection;	62	import java.util.Collection;
Lines 75-80 Link Here
75	import javax.swing.tree.TreeSelectionModel;	76	import javax.swing.tree.TreeSelectionModel;
76	import org.openide.actions.EditAction;	77	import org.openide.actions.EditAction;
77	import org.openide.cookies.EditCookie;	78	import org.openide.cookies.EditCookie;
		79	import org.openide.filesystems.FileObject;
		80	import org.openide.filesystems.FileUtil;
78	import org.openide.nodes.Node;	81	import org.openide.nodes.Node;
79	import org.openide.util.NbBundle;	82	import org.openide.util.NbBundle;
80	import org.openide.util.SharedClassObject;	83	import org.openide.util.SharedClassObject;
Lines 629-635 Link Here
629	private CopyTextAction newCopyTextAction(TreePath path) {	632	private CopyTextAction newCopyTextAction(TreePath path) {
630	try {	633	try {
631	MatchingObject mo = getMatchingObject(path);	634	MatchingObject mo = getMatchingObject(path);
632	String filePath = mo.getFile().getCanonicalPath(); // NPE, IOE	635
		636	FileObject fileObject = mo.getFileObject();
		637	File file = FileUtil.toFile(fileObject);
		638	String filePath = ( file != null )? file.getCanonicalPath() : fileObject.getPath();
633	String ctaName = NbBundle.getBundle(this.getClass()).	639	String ctaName = NbBundle.getBundle(this.getClass()).
634	getString("LBL_CopyFilePathAction"); // NOI18N	640	getString("LBL_CopyFilePathAction"); // NOI18N
635	CopyTextAction cta = new CopyTextAction(ctaName);	641	CopyTextAction cta = new CopyTextAction(ctaName);

Lines 135-141 Link Here

(-)a/utilities/src/org/netbeans/modules/search/ReplaceTask.java (-2 / +2 lines)
135	for(MatchingObject mo: matchingObjects) {	135	for(MatchingObject mo: matchingObjects) {
136	InvalidityStatus status = mo.checkValidity();	136	InvalidityStatus status = mo.checkValidity();
137	if (status != null) {	137	if (status != null) {
138	problems.add(status.getDescription(mo.getFile().getPath()));	138	problems.add(status.getDescription(mo.getFileObject().getPath()));
139	if (++errorsCount > MAX_ERRORS_CHECKED) {	139	if (++errorsCount > MAX_ERRORS_CHECKED) {
140	break;	140	break;
141	}	141	}
Lines 177-183 Link Here
177	if (status == null) {	177	if (status == null) {
178	obj.write(fileLock);	178	obj.write(fileLock);
179	} else {	179	} else {
180	errMessage = status.getDescription(obj.getFile().getPath());	180	errMessage = status.getDescription(obj.getFileObject().getPath());
181	}	181	}
182	} catch (FileAlreadyLockedException ex) {	182	} catch (FileAlreadyLockedException ex) {
183	errMessage = createMsgFileLocked(obj);	183	errMessage = createMsgFileLocked(obj);




                return;
            }
            
            FileObject fob = source.matchingObj.getFileObject(); 
                                                source.matchingObj.getFile());
            String mimeType = fob.getMIMEType();
            //We don't want the swing html editor kit, and even if we 
            //do get it, it will frequently throw a random NPE 

            return false;
        }
        
        boolean result = source.matchingObj.getFileObject()
                         .equals(item.matchingObj.getFileObject());
        if (result) {
            setLocation(item.getLocation());
            task.schedule(50);

Return to bug 194326

Lines 100-107 Link Here

(-)a/utilities/src/org/netbeans/modules/search/TextFetcher.java (-4 / +3 lines)
100	return;	100	return;
101	}	101	}
102		102
103	FileObject fob = FileUtil.toFileObject(	103	FileObject fob = source.matchingObj.getFileObject();
104	source.matchingObj.getFile());
105	String mimeType = fob.getMIMEType();	104	String mimeType = fob.getMIMEType();
106	//We don't want the swing html editor kit, and even if we	105	//We don't want the swing html editor kit, and even if we
107	//do get it, it will frequently throw a random NPE	106	//do get it, it will frequently throw a random NPE
Lines 166-173 Link Here
166	return false;	165	return false;
167	}	166	}
168		167
169	boolean result = source.matchingObj.getFile()	168	boolean result = source.matchingObj.getFileObject()
170	.equals(item.matchingObj.getFile());	169	.equals(item.matchingObj.getFileObject());
171	if (result) {	170	if (result) {
172	setLocation(item.getLocation());	171	setLocation(item.getLocation());
173	task.schedule(50);	172	task.schedule(50);

Lines 44-52 Link Here

(-)a/utilities/src/org/netbeans/modules/search/BasicSearchCriteria.java (-7 / +6 lines)
44		44
45	package org.netbeans.modules.search;	45	package org.netbeans.modules.search;
46		46
		47	import java.io.InputStream;
47	import java.io.FileNotFoundException;	48	import java.io.FileNotFoundException;
48	import java.io.IOException;	49	import java.io.IOException;
49	import java.io.FileInputStream;
50	import java.nio.charset.Charset;	50	import java.nio.charset.Charset;
51	import java.util.ArrayList;	51	import java.util.ArrayList;
52	import java.util.Collection;	52	import java.util.Collection;
Lines 62-68 Link Here
62	import javax.swing.event.ChangeEvent;	62	import javax.swing.event.ChangeEvent;
63	import javax.swing.event.ChangeListener;	63	import javax.swing.event.ChangeListener;
64	import org.netbeans.api.queries.FileEncodingQuery;	64	import org.netbeans.api.queries.FileEncodingQuery;
65	import org.netbeans.modules.search.TextDetail.DetailNode;
66	import org.openide.filesystems.FileObject;	65	import org.openide.filesystems.FileObject;
67	import org.openide.loaders.DataObject;	66	import org.openide.loaders.DataObject;
68	import org.openide.loaders.DataObjectNotFoundException;	67	import org.openide.loaders.DataObjectNotFoundException;
Lines 748-760 Link Here
748	lastCharset = FileEncodingQuery.getEncoding(fo);	747	lastCharset = FileEncodingQuery.getEncoding(fo);
749	SearchPattern sp = createSearchPattern();	748	SearchPattern sp = createSearchPattern();
750	BufferedCharSequence bcs = null;	749	BufferedCharSequence bcs = null;
751	try {	750	try {
752	FileInputStream fis = (FileInputStream)fo.getInputStream();	751	InputStream stream = fo.getInputStream();
753	bcs = new BufferedCharSequence(fis, lastCharset);	752	bcs = new BufferedCharSequence(stream, lastCharset, fo.getSize());
754	ArrayList<TextDetail> txtDetails = getTextDetails(bcs, fo, sp);	753	ArrayList<TextDetail> txtDetails = getTextDetails(bcs, fo, sp);
755	if (txtDetails.isEmpty()){	754	if (txtDetails.isEmpty()){
756	return false;	755	return false;
757	}	756	}
758	getDetailsMap().put(fo, txtDetails);	757	getDetailsMap().put(fo, txtDetails);
759	freeDataObject();	758	freeDataObject();
760	return true;	759	return true;