Java ITextFileBufferManager.disconnect方法代码示例

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
 * Save the AST int he Compilation Unit
 * 
 * @param testInterface
 * @param rewrite
 * @throws CoreException
 */
public static void save(CompilationUnit unit, ASTRewrite rewrite) throws CoreException {

	ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
	IPath path = unit.getJavaElement().getPath();
	try {
		bufferManager.connect(path, null);
		ITextFileBuffer textFileBuffer = bufferManager.getTextFileBuffer(path);
		IDocument document = textFileBuffer.getDocument();
		TextEdit edit = rewrite.rewriteAST(document, null);
		edit.apply(document);
		textFileBuffer.commit(null /* ProgressMonitor */, true /* Overwrite */);
	} catch (Exception e) {
		ResourceManager.logException(e);
	} finally {
		// disconnect the path
		bufferManager.disconnect(path, null);
	}
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
@Override
public void close() {
	synchronized (lock) {
		if (fIsClosed) {
			return;
		}

		fIsClosed= true;
		fDocument.removeDocumentListener(this);

		if (fTextFileBuffer != 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;
	}
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
public static IDocument getDocument(IPath fileSystemPath) throws CoreException {
	ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
	boolean connected = false;
	try {
		ITextFileBuffer buffer = manager.getTextFileBuffer(fileSystemPath, LocationKind.NORMALIZE);
		if (buffer == null) {
			// no existing file buffer..create one
			manager.connect(fileSystemPath, LocationKind.NORMALIZE, new NullProgressMonitor());
			connected = true;
			buffer = manager.getTextFileBuffer(fileSystemPath, LocationKind.NORMALIZE);
			if (buffer == null) {
				return null;
			}
		}
		return buffer.getDocument();
	} finally {
		if (connected) {
			manager.disconnect(fileSystemPath, LocationKind.NORMALIZE, new NullProgressMonitor());
		}
	}
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
private void processJavaSource(ICompilationUnit unit) throws Exception {
	ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
	IPath path = unit.getPath();
	try {
		bufferManager.connect(path, null);
		ITextFileBuffer textFileBuffer = bufferManager.getTextFileBuffer(path);
		IDocument doc = textFileBuffer.getDocument();
		if ((license !=null) && (license.length() > 0)) {
			processHeadLicense(doc);
		}
		if ((license_inline != null) && (license_inline.length() > 0)) {
			processInlineLicense(doc);
		}
		textFileBuffer.commit(null, false);
	} finally {
		bufferManager.disconnect(path, null);
	}
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
private TextEdit getTextEdit() throws CoreException {
	IDocument document= null;

	ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
	IPath path= fCU.getPath();

	if (manager != null && path != null) {
		manager.connect(path, LocationKind.NORMALIZE, null);
		try {
			ITextFileBuffer buffer= manager.getTextFileBuffer(path, LocationKind.NORMALIZE);
			if (buffer != null)
				document= buffer.getDocument();
		} finally {
			manager.disconnect(path, LocationKind.NORMALIZE, null);
		}
	}

	if (document == null)
		document= new Document(fCU.getSource());

	return fASTRewrite.rewriteAST(document, fCU.getJavaProject().getOptions(true));
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
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();
 }
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
public void close() {

		if (isClosed())
			return;

		IDocument d= fDocument;
		fDocument= new Document();
		fIsClosed= true;
		d.removeDocumentListener(this);

		if (fTextFileBuffer != null) {
			ITextFileBufferManager manager= FileBuffers.getTextFileBufferManager();
			try {
				if (fFileStore != null)
					manager.disconnectFileStore(fFileStore, new NullProgressMonitor());
				else
					manager.disconnect(fPath, fLocationKind, new NullProgressMonitor());
			} catch (CoreException x) {
				// ignore
			}
			fTextFileBuffer= null;
		}

		fireBufferChanged(new BufferChangedEvent(this, 0, 0, null));
		fBufferListeners.clear();
	}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
   * For each uncovered line in the resource, find the start and end of the line
   * and annotate it as not covered.
   */
  private void applyCodeCoverageMarker(IResource resource, List<Integer> uncoveredLines) throws CoreException, BadLocationException {
  	IFile iFile = (IFile) resource;
ITextFileBufferManager iTextFileBufferManager = FileBuffers.getTextFileBufferManager();
iTextFileBufferManager.connect(iFile.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
ITextFileBuffer iTextFileBuffer = iTextFileBufferManager.getTextFileBuffer(iFile.getFullPath(), LocationKind.IFILE);
IDocument iDoc = iTextFileBuffer.getDocument();
iTextFileBufferManager.disconnect(iFile.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());

for (Integer uncoveredLine : uncoveredLines) {
	int start = iDoc.getLineOffset(uncoveredLine - 1);
	int end = iDoc.getLineLength(uncoveredLine - 1);
	
	MarkerUtils.getInstance().applyCodeCoverageWarningMarker(resource, uncoveredLine, start, start + end, Messages.View_LineNotCovered);
}
  }
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/**
 * 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");
			}
		}
	}
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
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());
  }
}
 

import org.eclipse.core.filebuffers.ITextFileBufferManager; //导入方法依赖的package包/类
/** {@inheritDoc} */
public Change perform(IProgressMonitor pm) throws CoreException {
  if (fValidationState == null || fValidationState.isValid(needsSaving(), false).hasFatalError())
    return new NullChange();
  if (pm == null) pm = new NullProgressMonitor();
  ITextFileBufferManager manager = FileBuffers.getTextFileBufferManager();
  pm.beginTask("", 2); // $NON-NLS-1$
  ITextFileBuffer buffer = null;
  try {
    manager.connect(fFile.getFullPath(), LocationKind.IFILE, new SubProgressMonitor(pm, 1));
    buffer = manager.getTextFileBuffer(fFile.getFullPath(), LocationKind.IFILE);
    IDocument document = buffer.getDocument();
    ContentStamp currentStamp = ContentStamps.get(fFile, document);
    // perform the changes
    LinkedList list = new LinkedList();
    for (int index = 0; index < fUndos.length; index++) {
      UndoEdit edit = fUndos[index];
      UndoEdit redo = edit.apply(document, TextEdit.CREATE_UNDO);
      list.addFirst(redo);
    }

    // try to restore the document content stamp
    boolean success = ContentStamps.set(document, fContentStampToRestore);
    if (needsSaving()) {
      buffer.commit(pm, false);
      if (!success) {
        // We weren't able to restore document stamp.
        // Since we save restore the file stamp instead
        ContentStamps.set(fFile, fContentStampToRestore);
      }
    }
    return createUndoChange((UndoEdit[]) list.toArray(new UndoEdit[list.size()]), currentStamp);
  } catch (BadLocationException e) {
    throw Changes.asCoreException(e);
  } finally {
    if (buffer != null)
      manager.disconnect(fFile.getFullPath(), LocationKind.IFILE, new SubProgressMonitor(pm, 1));
  }
}