@Override
public void setContents(String contents) {
	synchronized (lock) {
		if (fDocument == null) {
			if (fTextFileBuffer != null) {
				fDocument = fTextFileBuffer.getDocument();
			} else {
				ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
				fDocument =  manager.createEmptyDocument(fFile.getFullPath(), LocationKind.IFILE);
			}
			fDocument.addDocumentListener(this);
			((ISynchronizable)fDocument).setLockObject(lock);
		}
	}
	if (!contents.equals(fDocument.get())) {
		fDocument.set(contents);
	}
}
 

@Override
public boolean acceptFile(IFile file) throws CoreException {
	IJavaElement element= JavaCore.create(file);
	if ((element != null && element.exists())) {
		return false;
	}

	// Only touch text files (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=114153 ):
	if (! FileBuffers.getTextFileBufferManager().isTextFileLocation(file.getFullPath(), false)) {
		return false;
	}

	IPath path= file.getProjectRelativePath();
	String segment= path.segment(0);
	if (segment != null && (segment.startsWith(".refactorings") || segment.startsWith(".deprecations"))) {
		return false;
	}

	return true;
}
 

/**
 * 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;
}
 

public static int getIndentationLevel(ASTNode node, ICompilationUnit unit) throws CoreException {
	IPath fullPath= unit.getCorrespondingResource().getFullPath();
	try{
		FileBuffers.getTextFileBufferManager().connect(fullPath, LocationKind.IFILE, new NullProgressMonitor());
		ITextFileBuffer buffer= FileBuffers.getTextFileBufferManager().getTextFileBuffer(fullPath, LocationKind.IFILE);
		try {
			IRegion region= buffer.getDocument().getLineInformationOfOffset(node.getStartPosition());
			return Strings.computeIndentUnits(buffer.getDocument().get(region.getOffset(), region.getLength()), unit.getJavaProject());
		} catch (BadLocationException exception) {
			JavaPlugin.log(exception);
		}
		return 0;
	} finally {
		FileBuffers.getTextFileBufferManager().disconnect(fullPath, LocationKind.IFILE, new NullProgressMonitor());
	}
}
 

private void checkDirtyFile(RefactoringStatus result, IFile file) {
	if (file == null || !file.exists())
		return;
	ITextFileBuffer buffer= FileBuffers.getTextFileBufferManager().getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
	if (buffer != null && buffer.isDirty()) {
		if (buffer.isStateValidated() && buffer.isSynchronized()) {
			result.addWarning(Messages.format(
				RefactoringCoreMessages.JavaDeleteProcessor_unsaved_changes,
				BasicElementLabels.getPathLabel(file.getFullPath(), false)));
		} else {
			result.addFatalError(Messages.format(
				RefactoringCoreMessages.JavaDeleteProcessor_unsaved_changes,
				BasicElementLabels.getPathLabel(file.getFullPath(), false)));
		}
	}
}
 

@Override
public boolean acceptFile(IFile file) throws CoreException {
	IJavaElement element= JavaCore.create(file);
	if ((element != null && element.exists()))
		return false;

	// Only touch text files (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=114153 ):
	if (! FileBuffers.getTextFileBufferManager().isTextFileLocation(file.getFullPath(), false))
		return false;

	IPath path= file.getProjectRelativePath();
	String segment= path.segment(0);
	if (segment != null && (segment.startsWith(".refactorings") || segment.startsWith(".deprecations"))) //$NON-NLS-1$ //$NON-NLS-2$
		return false;

	return true;
}
 

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

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;
}
 

/**
 * 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;
}
 

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;
}
 

/**
 * 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;
}
 

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

@Override
public void close() {
	synchronized (lock) {
		if (fIsClosed) {
			return;
		}

		fIsClosed= true;
		if (fDocument != null) {
			fDocument.removeDocumentListener(this);
		}

		if (fTextFileBuffer != null && fFile != null) {
			try {
				ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
				manager.disconnect(fFile.getFullPath(), LocationKind.NORMALIZE, null);
			} catch (CoreException x) {
				// ignore
			}
			fTextFileBuffer= null;
		}

		fireBufferChanged(new BufferChangedEvent(this, 0, 0, null));
		fBufferListeners.clear();
		fDocument = 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;
}
 

/**
 * Returns the text file buffer for the specified compilation unit.
 *
 * @param unit the compilation unit whose text file buffer to retrieve
 * @return the associated text file buffer, or <code>null</code> if no text file buffer is managed for the compilation unit
 */
public static ITextFileBuffer getTextFileBuffer(final ICompilationUnit unit) {
	Assert.isNotNull(unit);
	final IResource resource= unit.getResource();
	if (resource == null || resource.getType() != IResource.FILE) {
		return null;
	}
	return FileBuffers.getTextFileBufferManager().getTextFileBuffer(resource.getFullPath(), LocationKind.IFILE);
}
 

/**
 * Releases the text file buffer associated with the compilation unit.
 *
 * @param unit the compilation unit whose text file buffer has to be released
 * @throws CoreException if the buffer could not be successfully released
 */
public static void release(final ICompilationUnit unit) throws CoreException {
	Assert.isNotNull(unit);
	final IResource resource= unit.getResource();
	if (resource != null && resource.getType() == IResource.FILE) {
		FileBuffers.getTextFileBufferManager().disconnect(resource.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
	}
}
 

private static String getFileContents(IFile file) throws CoreException {
	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	IPath path= file.getFullPath();
	manager.connect(path, LocationKind.IFILE, new NullProgressMonitor());
	try {
		return manager.getTextFileBuffer(path, LocationKind.IFILE).getDocument().get();
	} finally {
		manager.disconnect(path, LocationKind.IFILE, new NullProgressMonitor());
	}
}
 

protected static void saveFileIfNeeded(IFile file, IProgressMonitor pm) throws CoreException {
	ITextFileBuffer buffer= FileBuffers.getTextFileBufferManager().getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
	if (buffer != null && buffer.isDirty() &&  buffer.isStateValidated() && buffer.isSynchronized()) {
		pm.beginTask("", 2); //$NON-NLS-1$
		buffer.commit(new SubProgressMonitor(pm, 1), false);
		file.refreshLocal(IResource.DEPTH_ONE, new SubProgressMonitor(pm, 1));
	}
	pm.done();
}
 

@Override
protected IDocument createEmptyDocument() {
	IDocument document= FileBuffers.getTextFileBufferManager().createEmptyDocument(null, LocationKind.IFILE);
	if (document instanceof ISynchronizable)
		((ISynchronizable)document).setLockObject(new Object());
	return document;
}
 

/**
 * 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;
}
 

/**
 * 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 file from the given {@link IDocument}.
 */
public static IFile getFile(IDocument document) {
	ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager(); // get
																					// the
																					// buffer
																					// manager
	ITextFileBuffer buffer = bufferManager.getTextFileBuffer(document);
	IPath location = buffer == null ? null : buffer.getLocation();
	if (location == null) {
		return null;
	}

	return ResourcesPlugin.getWorkspace().getRoot().getFile(location);
}
 

@Override
public void doSave(IProgressMonitor progressMonitor)
{
	if (getPreferenceStore().getBoolean(IPreferenceConstants.EDITOR_REMOVE_TRAILING_WHITESPACE))
	{
		// Remove any trailing spaces
		RemoveTrailingWhitespaceOperation removeSpacesOperation = new RemoveTrailingWhitespaceOperation();
		try
		{
			removeSpacesOperation.run(FileBuffers.getTextFileBufferManager().getTextFileBuffer(getDocument()),
					progressMonitor);
		}
		catch (Exception e)
		{
			IdeLog.logError(CommonEditorPlugin.getDefault(), "Error while removing the trailing whitespaces.", e); //$NON-NLS-1$
		}
	}
	if (getEditorInput() instanceof UntitledFileStorageEditorInput)
	{
		// forces to show save as dialog on untitled file
		performSaveAs(progressMonitor);
	}
	else
	{
		super.doSave(progressMonitor);
	}
}
 

/**
 * Returns the text file buffer for the specified compilation unit.
 *
 * @param unit the compilation unit whose text file buffer to retrieve
 * @return the associated text file buffer, or <code>null</code> if no text file buffer is managed for the compilation unit
 */
public static ITextFileBuffer getTextFileBuffer(final ICompilationUnit unit) {
	Assert.isNotNull(unit);
	final IResource resource= unit.getResource();
	if (resource == null || resource.getType() != IResource.FILE)
		return null;
	return FileBuffers.getTextFileBufferManager().getTextFileBuffer(resource.getFullPath(), LocationKind.IFILE);
}
 

/**
 * Releases the text file buffer associated with the compilation unit.
 *
 * @param unit the compilation unit whose text file buffer has to be released
 * @throws CoreException if the buffer could not be successfully released
 */
public static void release(final ICompilationUnit unit) throws CoreException {
	Assert.isNotNull(unit);
	final IResource resource= unit.getResource();
	if (resource != null && resource.getType() == IResource.FILE)
		FileBuffers.getTextFileBufferManager().disconnect(resource.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
}