Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2010 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation Tim Hanson (thanson@bea.com) - patch for https://bugs.eclipse.org/bugs/show_bug.cgi?id=126673 /
 
 package org.eclipse.jdt.internal.core;
 
 
 import  org.eclipse.core.resources.IFile;
 import  org.eclipse.core.resources.IResource;
 import  org.eclipse.core.resources.IResourceStatus;
 import  org.eclipse.core.runtime.CoreException;
 import  org.eclipse.core.runtime.IProgressMonitor;
 import  org.eclipse.core.runtime.ISafeRunnable;
 import  org.eclipse.core.runtime.SafeRunner;
 import  org.eclipse.core.runtime.content.IContentDescription;

See also:
IBuffer
 
 public class Buffer implements IBuffer {
 	protected IFile file;
 	protected int flags;
 	protected char[] contents;
 	protected IOpenable owner;
 	protected int gapStart = -1;
 	protected int gapEnd = -1;
 
 	protected Object lock = new Object();
 
 	protected static final int F_HAS_UNSAVED_CHANGES = 1;
 	protected static final int F_IS_READ_ONLY = 2;
 	protected static final int F_IS_CLOSED = 4;

Creates a new buffer on an underlying resource.
 
 protected Buffer(IFile fileIOpenable ownerboolean readOnly) {
 	this. = file;
 	this. = owner;
 	if (file == null) {
 		setReadOnly(readOnly);
 	}
 }

See also:
IBuffer
 
 public synchronized void addBufferChangedListener(IBufferChangedListener listener) {
 	if (this. == null) {
 		this. = new ArrayList(5);
 	}
 	if (!this..contains(listener)) {
 		this..add(listener);
 	}
 }
Append the text to the actual content, the gap is moved to the end of the text.
 
 public void append(char[] text) {
 	if (!isReadOnly()) {
 		if (text == null || text.length == 0) {
 			return;
 		}
 		int length = getLength();
 		synchronized(this.) {
 			if (this. == nullreturn;
 			moveAndResizeGap(lengthtext.length);
 			System.arraycopy(text, 0, this.lengthtext.length);
 			this. += text.length;
 		}
 		notifyChanged(new BufferChangedEvent(thislength, 0, new String(text)));
 	}
 }
Append the text to the actual content, the gap is moved to the end of the text.
 
 public void append(String text) {
 	if (text == null) {
 		return;
 	}
 	this.append(text.toCharArray());
 }

See also:
IBuffer
public void close() {
	BufferChangedEvent event = null;
	synchronized (this.) {
		if (isClosed())
			return;
		event = new BufferChangedEvent(this, 0, 0, null);
		this. = null;
		this. |= ;
	}
	notifyChanged(event); // notify outside of synchronized block
	synchronized(this) { // ensure that no other thread is adding/removing a listener at the same time (https://bugs.eclipse.org/bugs/show_bug.cgi?id=126673)
		this. = null;
	}

See also:
IBuffer
public char getChar(int position) {
	synchronized (this.) {
	    if (this. == nullreturn .;
		if (position < this.) {
			return this.[position];
		}
		int gapLength = this. - this.;
		return this.[position + gapLength];
	}

See also:
IBuffer
public char[] getCharacters() {
	synchronized (this.) {
		if (this. == nullreturn null;
		if (this. < 0) {
			return this.;
		}
		int length = this..length;
		char[] newContents = new char[length - this. + this.];
		System.arraycopy(this., 0, newContents, 0, this.);
		System.arraycopy(this.this.newContentsthis.length - this.);
		return newContents;
	}

See also:
IBuffer
public String getContents() {
	char[] chars = getCharacters();
	if (chars == nullreturn null;
	return new String(chars);

See also:
IBuffer
public int getLength() {
	synchronized (this.) {
		if (this. == nullreturn -1;
		int length = this. - this.;
		return (this..length - length);
	}

See also:
IBuffer
public IOpenable getOwner() {
	return this.;

See also:
IBuffer
public String getText(int offsetint length) {
	synchronized (this.) {
		if (this. == nullreturn ""//$NON-NLS-1$
		if (offset + length < this.)
			return new String(this.offsetlength);
		if (this. < offset) {
			int gapLength = this. - this.;
			return new String(this.offset + gapLengthlength);
		}
		StringBuffer buf = new StringBuffer();
		buf.append(this.offsetthis. - offset);
		buf.append(this.this.offset + length - this.);
		return buf.toString();
	}

See also:
IBuffer
public IResource getUnderlyingResource() {
	return this.;

See also:
IBuffer
public boolean hasUnsavedChanges() {
	return (this. & ) != 0;

See also:
IBuffer
public boolean isClosed() {
	return (this. & ) != 0;

See also:
IBuffer
public boolean isReadOnly() {
	return (this. & ) != 0;
Moves the gap to location and adjust its size to the anticipated change size. The size represents the expected range of the gap that will be filled after the gap has been moved. Thus the gap is resized to actual size + the specified size and moved to the given position.
protected void moveAndResizeGap(int positionint size) {
	char[] content = null;
	int oldSize = this. - this.;
	if (size < 0) {
		if (oldSize > 0) {
			content = new char[this..length - oldSize];
			System.arraycopy(this., 0, content, 0, this.);
			System.arraycopy(this.this.contentthis.content.length - this.);
			this. = content;
		}
		this. = this. = position;
		return;
	}
	content = new char[this..length + (size - oldSize)];
	int newGapStart = position;
	int newGapEnd = newGapStart + size;
	if (oldSize == 0) {
		System.arraycopy(this., 0, content, 0, newGapStart);
		System.arraycopy(this.newGapStartcontentnewGapEndcontent.length - newGapEnd);
else
		if (newGapStart < this.) {
			int delta = this. - newGapStart;
			System.arraycopy(this., 0, content, 0, newGapStart);
			System.arraycopy(this.newGapStartcontentnewGapEnddelta);
			System.arraycopy(this.this.contentnewGapEnd + deltathis..length - this.);
else {
			int delta = newGapStart - this.;
			System.arraycopy(this., 0, content, 0, this.);
			System.arraycopy(this.this.contentthis.delta);
			System.arraycopy(this.this. + deltacontentnewGapEndcontent.length - newGapEnd);
		}
	this. = content;
	this. = newGapStart;
	this. = newGapEnd;
Notify the listeners that this buffer has changed. To avoid deadlock, this should not be called in a synchronized block.
protected void notifyChanged(final BufferChangedEvent event) {
	ArrayList listeners = this.;
	if (listeners != null) {
		for (int i = 0, size = listeners.size(); i < size; ++i) {
			final IBufferChangedListener listener = (IBufferChangedListenerlisteners.get(i);
			SafeRunner.run(new ISafeRunnable() {
				public void handleException(Throwable exception) {
					Util.log(exception"Exception occurred in listener of buffer change notification"); //$NON-NLS-1$
				}
				public void run() throws Exception {
					listener.bufferChanged(event);
				}
			});
		}
	}

See also:
IBuffer
public synchronized void removeBufferChangedListener(IBufferChangedListener listener) {
	if (this. != null) {
		this..remove(listener);
		if (this..size() == 0) {
			this. = null;
		}
	}
Replaces length characters starting from position with text. After that operation, the gap is placed at the end of the inserted text.
public void replace(int positionint lengthchar[] text) {
	if (!isReadOnly()) {
		int textLength = text == null ? 0 : text.length;
		synchronized (this.) {
			if (this. == nullreturn;
			// move gap
			moveAndResizeGap(position + lengthtextLength - length);
			// overwrite
			int min = Math.min(textLengthlength);
			if (min > 0) {
				System.arraycopy(text, 0, this.positionmin);
			}
			if (length > textLength) {
				// enlarge the gap
				this. -= length - textLength;
else if (textLength > length) {
				// shrink gap
				this. += textLength - length;
				System.arraycopy(text, 0, this.positiontextLength);
			}
		}
		String string = null;
		if (textLength > 0) {
			string = new String(text);
		}
		notifyChanged(new BufferChangedEvent(thispositionlengthstring));
	}
Replaces length characters starting from position with text. After that operation, the gap is placed at the end of the inserted text.
public void replace(int positionint lengthString text) {
	this.replace(positionlengthtext == null ? null : text.toCharArray());

See also:
IBuffer
public void save(IProgressMonitor progressboolean forcethrows JavaModelException {
	// determine if saving is required
	if (isReadOnly() || this. == null) {
		return;
	}
		return;
	// use a platform operation to update the resource contents
	try {
		String stringContents = getContents();
		if (stringContents == nullreturn;
		// Get encoding
		String encoding = null;
		try {
			encoding = this..getCharset();
		}
		catch (CoreException ce) {
			// use no encoding
		}
		// Create bytes array
		byte[] bytes = encoding == null
stringContents.getBytes()
stringContents.getBytes(encoding);
		// Special case for UTF-8 BOM files
		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=110576
		if (encoding != null && encoding.equals(.......)) {
			IContentDescription description;
			try {
				description = this..getContentDescription();
catch (CoreException e) {
				if (e.getStatus().getCode() != IResourceStatus.RESOURCE_NOT_FOUND)
					throw e;
				// file no longer exist (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=234307 )
				description = null;
			}
			if (description != null && description.getProperty(IContentDescription.BYTE_ORDER_MARK) != null) {
				int bomLength= IContentDescription.BOM_UTF_8.length;
				byte[] bytesWithBOMnew byte[bytes.length + bomLength];
				System.arraycopy(IContentDescription.BOM_UTF_8, 0, bytesWithBOM, 0, bomLength);
				System.arraycopy(bytes, 0, bytesWithBOMbomLengthbytes.length);
				bytesbytesWithBOM;
			}
		}
		// Set file contents
		if (this..exists()) {
			this..setContents(
				stream,
				force ? IResource.FORCE | IResource.KEEP_HISTORY : IResource.KEEP_HISTORY,
				null);
else {
			this..create(streamforcenull);
		}
catch (IOException e) {
catch (CoreException e) {
		throw new JavaModelException(e);
	}
	// the resource no longer has unsaved changes

See also:
IBuffer
public void setContents(char[] newContents) {
	// allow special case for first initialization
	// after creation by buffer factory
	if (this. == null) {
		synchronized (this.) {
			this. = newContents;
		}
		return;
	}
	if (!isReadOnly()) {
		String string = null;
		if (newContents != null) {
			string = new String(newContents);
		}
		synchronized (this.) {
			if (this. == nullreturn// ignore if buffer is closed (as per spec)
			this. = newContents;
			this. = -1;
			this. = -1;
		}
		BufferChangedEvent event = new BufferChangedEvent(this, 0, getLength(), string);
	}

See also:
IBuffer
public void setContents(String newContents) {
	this.setContents(newContents.toCharArray());
Sets this Buffer to be read only.
protected void setReadOnly(boolean readOnly) {
	if (readOnly) {
else {
		this. &= ~();
	}
public String toString() {
	StringBuffer buffer = new StringBuffer();
	buffer.append("Owner: " + ((JavaElement)this.).toStringWithAncestors()); //$NON-NLS-1$
	buffer.append("\nHas unsaved changes: " + hasUnsavedChanges()); //$NON-NLS-1$
	buffer.append("\nIs readonly: " + isReadOnly()); //$NON-NLS-1$
	buffer.append("\nIs closed: " + isClosed()); //$NON-NLS-1$
	buffer.append("\nContents:\n"); //$NON-NLS-1$
	char[] charContents = getCharacters();
	if (charContents == null) {
		buffer.append("<null>"); //$NON-NLS-1$
else {
		int length = charContents.length;
		for (int i = 0; i < lengthi++) {
			char c = charContents[i];
			switch (c) {
				case '\n':
					buffer.append("\\n\n"); //$NON-NLS-1$
					break;
				case '\r':
					if (i < length-1 && this.[i+1] == '\n') {
						buffer.append("\\r\\n\n"); //$NON-NLS-1$
						i++;
else {
						buffer.append("\\r\n"); //$NON-NLS-1$
					}
					break;
				default:
					buffer.append(c);
					break;
			}
		}
	}
	return buffer.toString();
New to GrepCode? Check out our FAQ X