Java Code Examples for org.eclipse.core.filebuffers.ITextFileBufferManager#getTextFileBuffer()

/**
 * Reads the content of the java.io.File.
 * 
 * @param file the file whose content has to be read
 * @return the content of the file
 * @throws CoreException if the file could not be successfully connected or disconnected
 */
private static String getFileContent(File file) throws CoreException {
	String content= null;
	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();

	IPath fullPath= new Path(file.getAbsolutePath());
	manager.connect(fullPath, LocationKind.LOCATION, null);
	try {
		ITextFileBuffer buffer= manager.getTextFileBuffer(fullPath, LocationKind.LOCATION);
		if (buffer != null) {
			content= buffer.getDocument().get();
		}
	} finally {
		manager.disconnect(fullPath, LocationKind.LOCATION, null);
	}
	return content;
}
 

/**
 * Reads the content of the IFile.
 * 
 * @param file the file whose content has to be read
 * @return the content of the file
 * @throws CoreException if the file could not be successfully connected or disconnected
 */
private static String getIFileContent(IFile file) throws CoreException {
	String content= null;
	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	IPath fullPath= file.getFullPath();
	manager.connect(fullPath, LocationKind.IFILE, null);
	try {
		ITextFileBuffer buffer= manager.getTextFileBuffer(fullPath, LocationKind.IFILE);
		if (buffer != null) {
			content= buffer.getDocument().get();
		}
	} finally {
		manager.disconnect(fullPath, LocationKind.IFILE, null);
	}

	return content;
}
 

/**
 * Reads the content of the IFile.
 *
 * @param file
 *            the file whose content has to be read
 * @return the content of the file
 * @throws CoreException
 *             if the file could not be successfully connected or disconnected
 */
private static String getIFileContent(IFile file) throws CoreException {
	String content = null;
	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
	IPath fullPath = file.getFullPath();
	manager.connect(fullPath, LocationKind.IFILE, null);
	try {
		ITextFileBuffer buffer = manager.getTextFileBuffer(fullPath, LocationKind.IFILE);
		if (buffer != null) {
			content = buffer.getDocument().get();
		}
	} finally {
		manager.disconnect(fullPath, LocationKind.IFILE, null);
	}

	return content;
}
 

/**
 * Reads the content of the java.io.File.
 *
 * @param file
 *            the file whose content has to be read
 * @return the content of the file
 * @throws CoreException
 *             if the file could not be successfully connected or disconnected
 */
private static String getFileContent(File file) throws CoreException {
	String content = null;
	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();

	IPath fullPath = new Path(file.getAbsolutePath());
	manager.connect(fullPath, LocationKind.LOCATION, null);
	try {
		ITextFileBuffer buffer = manager.getTextFileBuffer(fullPath, LocationKind.LOCATION);
		if (buffer != null) {
			content = buffer.getDocument().get();
		}
	} finally {
		manager.disconnect(fullPath, LocationKind.LOCATION, null);
	}
	return content;
}
 

/**
 * Returns an {@link IDocument} for the given {@link IFile}.
 *
 * @param file an {@link IFile}
 * @return a document with the contents of the file,
 * or <code>null</code> if the file can not be opened.
 */
public static IDocument toDocument(IFile file) {
	if (file != null && file.isAccessible()) {
		IPath path = file.getFullPath();
		ITextFileBufferManager fileBufferManager = FileBuffers.getTextFileBufferManager();
		LocationKind kind = LocationKind.IFILE;
		try {
			fileBufferManager.connect(path, kind, new NullProgressMonitor());
			ITextFileBuffer fileBuffer = fileBufferManager.getTextFileBuffer(path, kind);
			if (fileBuffer != null) {
				return fileBuffer.getDocument();
			}
		} catch (CoreException e) {
			JavaLanguageServerPlugin.logException("Failed to convert "+ file +"  to an IDocument", e);
		} finally {
			try {
				fileBufferManager.disconnect(path, kind, new NullProgressMonitor());
			} catch (CoreException slurp) {
				//Don't care
			}
		}
	}
	return null;
}
 

private static void evaluateTextEditor(Map<IFile, IDocument> result, IEditorPart ep, IFile filter) {
    IEditorInput input = ep.getEditorInput();
    if (input instanceof IFileEditorInput) {
        IFile file = ((IFileEditorInput) input).getFile();
        if (filter == null || filter.equals(file)) { 
            if (!result.containsKey(file)) { // take the first editor found
                ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
                ITextFileBuffer textFileBuffer = bufferManager
                        .getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
                if (textFileBuffer != null) {
                    // file buffer has precedence
                    result.put(file, textFileBuffer.getDocument());
                }
                else {
                    // use document provider
                    IDocument document = ((ITextEditor) ep).getDocumentProvider().getDocument(input);
                    if (document != null) {
                        result.put(file, document);
                    }
                }
            }
        }
    }
}
 

public static Position getPosition(IFile file, TextSpan textSpan) throws BadLocationException {
	ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
	ITextFileBuffer buffer = bufferManager.getTextFileBuffer(file.getLocation(), LocationKind.IFILE);
	if (buffer != null) {
		return getPosition(buffer.getDocument(), textSpan);
	}
	IDocumentProvider provider = new TextFileDocumentProvider();
	try {
		provider.connect(file);
		IDocument document = provider.getDocument(file);
		if (document != null) {
			return getPosition(document, textSpan);
		}
	} catch (CoreException e) {
	} finally {
		provider.disconnect(file);
	}
	return null;
}
 

private void initialize() {
	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	try {
		if (fFileStore != null) {
			manager.connectFileStore(fFileStore, new NullProgressMonitor());
			fTextFileBuffer= manager.getFileStoreTextFileBuffer(fFileStore);
		} else {
			manager.connect(fPath, fLocationKind, new NullProgressMonitor());
			fTextFileBuffer= manager.getTextFileBuffer(fPath, fLocationKind);
		}
		fDocument= fTextFileBuffer.getDocument();
	} catch (CoreException x) {
		fDocument= manager.createEmptyDocument(fPath, fLocationKind);
		if (fDocument instanceof ISynchronizable)
			((ISynchronizable)fDocument).setLockObject(new Object());
	}
	fDocument.addDocumentListener(this);
	fIsClosed= false;
}
 

private long getDocumentStamp(IFile file, IProgressMonitor monitor) throws CoreException {
 final ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
 final IPath path= file.getFullPath();

 monitor.beginTask("", 2); //$NON-NLS-1$

 ITextFileBuffer buffer= null;
 try {
 	manager.connect(path, LocationKind.IFILE, new SubProgressMonitor(monitor, 1));
  buffer= manager.getTextFileBuffer(path, LocationKind.IFILE);
	    IDocument document= buffer.getDocument();

	    if (document instanceof IDocumentExtension4) {
			return ((IDocumentExtension4)document).getModificationStamp();
		} else {
			return file.getModificationStamp();
		}
 } finally {
 	if (buffer != null)
 		manager.disconnect(path, LocationKind.IFILE, new SubProgressMonitor(monitor, 1));
 	monitor.done();
 }
}
 

public static ITextFileBuffer getTextFileBuffer(ITextFileBufferManager fbm, Path filePath) {
	
	ITextFileBuffer fileBuffer;
	fileBuffer = fbm.getTextFileBuffer(epath(filePath), LocationKind.NORMALIZE);
	if(fileBuffer != null) {
		return fileBuffer;
	}
	
	// Could be an external file, try alternative API:
	fileBuffer = fbm.getFileStoreTextFileBuffer(FileBuffers.getFileStoreAtLocation(epath(filePath)));
	if(fileBuffer != null) {
		return fileBuffer;
	}
	
	// Fall back, try LocationKind.LOCATION
	fileBuffer = fbm.getTextFileBuffer(epath(filePath), LocationKind.LOCATION);
	if(fileBuffer != null) {
		return fileBuffer;
	}
	
	return null;
}
 

/**
 * @param path the path we're interested in
 * @return a file buffer to be used.
 */
public static ITextFileBuffer getBufferFromPath(IPath path) {
    try {
        //eclipse 3.3 onwards
        ITextFileBufferManager textFileBufferManager = ITextFileBufferManager.DEFAULT;
        if (textFileBufferManager != null) {//we don't have it in tests
            ITextFileBuffer textFileBuffer = textFileBufferManager.getTextFileBuffer(path,
                    LocationKind.LOCATION);

            if (textFileBuffer != null) { //we don't have it when it is not properly refreshed
                return textFileBuffer;
            }
        }
        return null;

    } catch (Throwable e) {
        //private static final IWorkspaceRoot WORKSPACE_ROOT= ResourcesPlugin.getWorkspace().getRoot();
        //throws an error and we don't even have access to the FileBuffers class in tests
        if (!IN_TESTS) {
            Log.log("Unable to get doc from text file buffer");
        }
        return null;
    }
}
 

/**
 * Returns the project that belongs to the given document.
 * Thanks to Nitin Dahyabhai for the tip.
 * 
 * @param document
 * @return the project or <code>null</code> if no project was found
 */
private static IProject getProject(IDocument document) {
    ITextFileBufferManager fileBufferMgr = FileBuffers.getTextFileBufferManager();
    ITextFileBuffer fileBuffer = fileBufferMgr.getTextFileBuffer(document);
    
    if (fileBuffer != null) {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IResource res = workspace.getRoot().findMember(fileBuffer.getLocation());
        if (res != null) return res.getProject();        	
    }
    return null;
}
 

private static ITextFileBuffer getBuffer(IFile file) {
    try {
        ITextFileBufferManager manager = ITextFileBufferManager.DEFAULT;
        return manager.getTextFileBuffer(file.getFullPath(), org.eclipse.core.filebuffers.LocationKind.IFILE);
    } catch (Throwable e) {//NoSuchMethod/NoClassDef exception 
        if (e instanceof ClassNotFoundException || e instanceof LinkageError || e instanceof NoSuchMethodException
                || e instanceof NoSuchMethodError || e instanceof NoClassDefFoundError) {
            return null; // that's ok -- not available in Eclipse 3.2
        }
        throw new RuntimeException(e);
    }
}
 

public boolean isContainerDirty(TypeNameMatch match) {
	ICompilationUnit cu= match.getType().getCompilationUnit();
	if (cu == null) {
		return false;
	}
	IResource resource= cu.getResource();
	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	ITextFileBuffer textFileBuffer= manager.getTextFileBuffer(resource.getFullPath(), LocationKind.IFILE);
	if (textFileBuffer != null) {
		return textFileBuffer.isDirty();
	}
	return false;
}
 

/**
 * Returns the {@link IDocument} from the given file and null if it's not
 * possible.
 */
public static IDocument getDocument(IPath location) {
	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();

	boolean connected = false;
	try {
		ITextFileBuffer buffer = manager.getTextFileBuffer(location, LocationKind.NORMALIZE);
		if (buffer == null) {
			// no existing file buffer..create one
			manager.connect(location, LocationKind.NORMALIZE, new NullProgressMonitor());
			connected = true;
			buffer = manager.getTextFileBuffer(location, LocationKind.NORMALIZE);
			if (buffer == null) {
				return null;
			}
		}

		return buffer.getDocument();
	} catch (CoreException ce) {
		TypeScriptCorePlugin.logError(ce, "Error while getting document from file");
		return null;
	} finally {
		if (connected) {
			try {
				manager.disconnect(location, LocationKind.NORMALIZE, new NullProgressMonitor());
			} catch (CoreException e) {
				TypeScriptCorePlugin.logError(e, "Error while getting document from file");
			}
		}
	}
}
 

/**
 * Returns the {@link IResource} from the given text viewer and null otherwise.
 * 
 * @param textViewer
 * @return the {@link IResource} from the given text viewer and null otherwise.
 */
private IResource getResource(ITextViewer textViewer) {
	ITextEditor textEditor = (ITextEditor) getAdapter(ITextEditor.class);
	if (textEditor != null) {
		return EditorUtils.getResource(textEditor);
	}
	ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
	ITextFileBuffer textFileBuffer = bufferManager.getTextFileBuffer(textViewer.getDocument());
	if (textFileBuffer != null) {
		IPath location = textFileBuffer.getLocation();
		return ResourcesPlugin.getWorkspace().getRoot().findMember(location);
	}
	return null;
}
 

private IDocument getOpenDocument(IFile file, Map<IFile, IDocument> documentsInEditors) {
	IDocument document= documentsInEditors.get(file);
	if (document == null) {
		ITextFileBufferManager bufferManager= FileBuffers.getTextFileBufferManager();
		ITextFileBuffer textFileBuffer= bufferManager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
		if (textFileBuffer != null) {
			document= textFileBuffer.getDocument();
		}
	}
	return document;
}
 

public DocumentAdapter(IOpenable owner, IFile file) {
	fOwner = owner;
	fFile = file;
	fBufferListeners = new ArrayList<>(3);
	fIsClosed = false;

	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	try {
		manager.connect(file.getFullPath(), LocationKind.IFILE, null);
		fTextFileBuffer= manager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
	} catch (CoreException e) {
	}
}
 

public BufferFixture(ITextFileBufferManager fbm, IPath path, LocationKind locationKind, 
		FixtureSourceModelManager sourceModelMgr) throws CoreException {
	this.path = path;
	this.locationKind = locationKind;
	this.sourceModelMgr = sourceModelMgr;
	this.fbm = assertNotNull(fbm);
	fbm.connect(path, locationKind, pm);
	buffer = fbm.getTextFileBuffer(path, locationKind);
}
 

private TextChange createFileChange(IFile file, Pattern pattern, Collection<Match> matches,
        RefactoringStatus resultingStatus, Collection<MatchGroup> matchGroups)
                throws PatternSyntaxException, CoreException {
    PositionTracker tracker = InternalSearchUI.getInstance().getPositionTracker();

    TextFileChange change = new SynchronizedTextFileChange(MessageFormat.format(
            SearchMessages.ReplaceRefactoring_group_label_change_for_file, file.getName()), file);
    change.setEdit(new MultiTextEdit());

    ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
    manager.connect(file.getFullPath(), LocationKind.IFILE, null);
    try {
        ITextFileBuffer textFileBuffer = manager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
        if (textFileBuffer == null) {
            resultingStatus
                    .addError(MessageFormat.format(SearchMessages.ReplaceRefactoring_error_accessing_file_buffer,
                            file.getName()));
            return null;
        }
        IDocument document = textFileBuffer.getDocument();
        String lineDelimiter = TextUtilities.getDefaultLineDelimiter(document);

        for (Iterator<Match> iterator = matches.iterator(); iterator.hasNext();) {
            Match match = iterator.next();
            int offset = match.getOffset();
            int length = match.getLength();
            Position currentPosition = tracker.getCurrentPosition(match);
            if (currentPosition != null) {
                offset = currentPosition.offset;
                if (length != currentPosition.length) {
                    resultingStatus.addError(MessageFormat.format(
                            SearchMessages.ReplaceRefactoring_error_match_content_changed, file.getName()));
                    continue;
                }
            }

            String originalText = getOriginalText(document, offset, length);
            if (originalText == null) {
                resultingStatus.addError(MessageFormat.format(
                        SearchMessages.ReplaceRefactoring_error_match_content_changed, file.getName()));
                continue;
            }

            String replacementString = computeReplacementString(pattern, originalText, fReplaceString,
                    lineDelimiter);
            if (replacementString == null) {
                resultingStatus.addError(MessageFormat.format(
                        SearchMessages.ReplaceRefactoring_error_match_content_changed, file.getName()));
                continue;
            }

            ReplaceEdit replaceEdit = new ReplaceEdit(offset, length, replacementString);
            change.addEdit(replaceEdit);
            TextEditChangeGroup textEditChangeGroup = new TextEditChangeGroup(change, new TextEditGroup(
                    SearchMessages.ReplaceRefactoring_group_label_match_replace, replaceEdit));
            change.addTextEditChangeGroup(textEditChangeGroup);
            matchGroups.add(new MatchGroup(textEditChangeGroup, match));
        }
    } finally {
        manager.disconnect(file.getFullPath(), LocationKind.IFILE, null);
    }
    return change;
}