StringContent.java

/*
 * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
packagejavax.swing.text;

importjava.util.Vector;
importjava.io.Serializable;
importjavax.swing.undo.*;

/**
 * An implementation of the AbstractDocument.Content interface that is
 * a brute force implementation that is useful for relatively small
 * documents and/or debugging. It manages the character content
 * as a simple character array. It is also quite inefficient.
 * <p>
 * It is generally recommended that the gap buffer or piece table
 * implementations be used instead. This buffer does not scale up
 * to large sizes.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @author Timothy Prinzing
 */
@SuppressWarnings("serial") // Same-version serialization only
publicfinalclassStringContentimplementsAbstractDocument.Content, Serializable {

/**
 * Creates a new StringContent object. Initial size defaults to 10.
 */
publicStringContent() {
this(10);
 }

/**
 * Creates a new StringContent object, with the initial
 * size specified. If the length is &lt; 1, a size of 1 is used.
 *
 * @param initialLength the initial size
 */
publicStringContent(intinitialLength) {
if (initialLength < 1) {
initialLength = 1;
 }
data = newchar[initialLength];
data[0] = '\n';
count = 1;
 }

/**
 * Returns the length of the content.
 *
 * @return the length &gt;= 1
 * @see AbstractDocument.Content#length
 */
publicintlength() {
returncount;
 }

/**
 * Inserts a string into the content.
 *
 * @param where the starting position &gt;= 0 &amp;&amp; &lt; length()
 * @param str the non-null string to insert
 * @return an UndoableEdit object for undoing
 * @throws BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#insertString
 */
publicUndoableEditinsertString(intwhere, Stringstr) throwsBadLocationException {
if (where >= count || where < 0) {
thrownewBadLocationException("Invalid location", count);
 }
char[] chars = str.toCharArray();
replace(where, 0, chars, 0, chars.length);
if (marks != null) {
updateMarksForInsert(where, str.length());
 }
returnnewInsertUndo(where, str.length());
 }

/**
 * Removes part of the content. where + nitems must be &lt; length().
 *
 * @param where the starting position &gt;= 0
 * @param nitems the number of characters to remove &gt;= 0
 * @return an UndoableEdit object for undoing
 * @throws BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#remove
 */
publicUndoableEditremove(intwhere, intnitems) throwsBadLocationException {
if (where + nitems >= count) {
thrownewBadLocationException("Invalid range", count);
 }
StringremovedString = getString(where, nitems);
UndoableEditedit = newRemoveUndo(where, removedString);
replace(where, nitems, empty, 0, 0);
if (marks != null) {
updateMarksForRemove(where, nitems);
 }
returnedit;

 }

/**
 * Retrieves a portion of the content. where + len must be &lt;= length().
 *
 * @param where the starting position &gt;= 0
 * @param len the length to retrieve &gt;= 0
 * @return a string representing the content; may be empty
 * @throws BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#getString
 */
publicStringgetString(intwhere, intlen) throwsBadLocationException {
if (where + len > count) {
thrownewBadLocationException("Invalid range", count);
 }
returnnewString(data, where, len);
 }

/**
 * Retrieves a portion of the content. where + len must be &lt;= length()
 *
 * @param where the starting position &gt;= 0
 * @param len the number of characters to retrieve &gt;= 0
 * @param chars the Segment object to return the characters in
 * @throws BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#getChars
 */
publicvoidgetChars(intwhere, intlen, Segmentchars) throwsBadLocationException {
if (where + len > count) {
thrownewBadLocationException("Invalid location", count);
 }
chars.array = data;
chars.offset = where;
chars.count = len;
 }

/**
 * Creates a position within the content that will
 * track change as the content is mutated.
 *
 * @param offset the offset to create a position for &gt;= 0
 * @return the position
 * @throws BadLocationException if the specified position is invalid
 */
publicPositioncreatePosition(intoffset) throwsBadLocationException {
// some small documents won't have any sticky positions
// at all, so the buffer is created lazily.
if (marks == null) {
marks = newVector<PosRec>();
 }
returnnewStickyPosition(offset);
 }

// --- local methods ---------------------------------------

/**
 * Replaces some of the characters in the array
 * @param offset offset into the array to start the replace
 * @param length number of characters to remove
 * @param replArray replacement array
 * @param replOffset offset into the replacement array
 * @param replLength number of character to use from the
 * replacement array.
 */
voidreplace(intoffset, intlength,
char[] replArray, intreplOffset, intreplLength) {
intdelta = replLength - length;
intsrc = offset + length;
intnmove = count - src;
intdest = src + delta;
if ((count + delta) >= data.length) {
// need to grow the array
intnewLength = Math.max(2*data.length, count + delta);
char[] newData = newchar[newLength];
System.arraycopy(data, 0, newData, 0, offset);
System.arraycopy(replArray, replOffset, newData, offset, replLength);
System.arraycopy(data, src, newData, dest, nmove);
data = newData;
 } else {
// patch the existing array
System.arraycopy(data, src, data, dest, nmove);
System.arraycopy(replArray, replOffset, data, offset, replLength);
 }
count = count + delta;
 }

voidresize(intncount) {
char[] ndata = newchar[ncount];
System.arraycopy(data, 0, ndata, 0, Math.min(ncount, count));
data = ndata;
 }

synchronizedvoidupdateMarksForInsert(intoffset, intlength) {
if (offset == 0) {
// zero is a special case where we update only
// marks after it.
offset = 1;
 }
intn = marks.size();
for (inti = 0; i < n; i++) {
PosRecmark = marks.elementAt(i);
if (mark.unused) {
// this record is no longer used, get rid of it
marks.removeElementAt(i);
i -= 1;
n -= 1;
 } elseif (mark.offset >= offset) {
mark.offset += length;
 }
 }
 }

synchronizedvoidupdateMarksForRemove(intoffset, intlength) {
intn = marks.size();
for (inti = 0; i < n; i++) {
PosRecmark = marks.elementAt(i);
if (mark.unused) {
// this record is no longer used, get rid of it
marks.removeElementAt(i);
i -= 1;
n -= 1;
 } elseif (mark.offset >= (offset + length)) {
mark.offset -= length;
 } elseif (mark.offset >= offset) {
mark.offset = offset;
 }
 }
 }

/**
 * Returns a Vector containing instances of UndoPosRef for the
 * Positions in the range
 * <code>offset</code> to <code>offset</code> + <code>length</code>.
 * If <code>v</code> is not null the matching Positions are placed in
 * there. The vector with the resulting Positions are returned.
 * <p>
 * This is meant for internal usage, and is generally not of interest
 * to subclasses.
 *
 * @param v the Vector to use, with a new one created on null
 * @param offset the starting offset &gt;= 0
 * @param length the length &gt;= 0
 * @return the set of instances
 */
@SuppressWarnings({"rawtypes", "unchecked"}) // UndoPosRef type cannot be exposed
protectedVectorgetPositionsInRange(Vectorv, intoffset,
intlength) {
intn = marks.size();
intend = offset + length;
VectorplaceIn = (v == null) ? newVector() : v;
for (inti = 0; i < n; i++) {
PosRecmark = marks.elementAt(i);
if (mark.unused) {
// this record is no longer used, get rid of it
marks.removeElementAt(i);
i -= 1;
n -= 1;
 } elseif(mark.offset >= offset && mark.offset <= end)
placeIn.addElement(newUndoPosRef(mark));
 }
returnplaceIn;
 }

/**
 * Resets the location for all the UndoPosRef instances
 * in <code>positions</code>.
 * <p>
 * This is meant for internal usage, and is generally not of interest
 * to subclasses.
 *
 * @param positions the positions of the instances
 */
@SuppressWarnings("rawtypes") // UndoPosRef type cannot be exposed
protectedvoidupdateUndoPositions(Vectorpositions) {
for(intcounter = positions.size() - 1; counter >= 0; counter--) {
UndoPosRefref = (UndoPosRef) positions.elementAt(counter);
// Check if the Position is still valid.
if(ref.rec.unused) {
positions.removeElementAt(counter);
 }
else
ref.resetLocation();
 }
 }

privatestaticfinalchar[] empty = newchar[0];
privatechar[] data;
privateintcount;
transientVector<PosRec> marks;

/**
 * holds the data for a mark... separately from
 * the real mark so that the real mark can be
 * collected if there are no more references to
 * it.... the update table holds only a reference
 * to this grungy thing.
 */
staticfinalclassPosRec {

PosRec(intoffset) {
this.offset = offset;
 }

intoffset;
booleanunused;
 }

/**
 * This really wants to be a weak reference but
 * in 1.1 we don't have a 100% pure solution for
 * this... so this class tries to hack a solution
 * to causing the marks to be collected.
 */
finalclassStickyPositionimplementsPosition {

StickyPosition(intoffset) {
rec = newPosRec(offset);
marks.addElement(rec);
 }

publicintgetOffset() {
returnrec.offset;
 }

@SuppressWarnings("removal")
protectedvoidfinalize() throwsThrowable {
// schedule the record to be removed later
// on another thread.
rec.unused = true;
 }

publicStringtoString() {
returnInteger.toString(getOffset());
 }

PosRecrec;
 }

/**
 * Used to hold a reference to a Position that is being reset as the
 * result of removing from the content.
 */
staticfinalclassUndoPosRef {
UndoPosRef(PosRecrec) {
this.rec = rec;
this.undoLocation = rec.offset;
 }

/**
 * Resets the location of the Position to the offset when the
 * receiver was instantiated.
 */
protectedvoidresetLocation() {
rec.offset = undoLocation;
 }

/** Location to reset to when resetLocation is invoked. */
protectedintundoLocation;
/** Position to reset offset. */
protectedPosRecrec;
 }

/**
 * UnoableEdit created for inserts.
 */
classInsertUndoextendsAbstractUndoableEdit {
protectedInsertUndo(intoffset, intlength) {
super();
this.offset = offset;
this.length = length;
 }

publicvoidundo() throwsCannotUndoException {
super.undo();
try {
synchronized(StringContent.this) {
// Get the Positions in the range being removed.
if(marks != null)
posRefs = getPositionsInRange(null, offset, length);
string = getString(offset, length);
remove(offset, length);
 }
 } catch (BadLocationExceptionbl) {
thrownewCannotUndoException();
 }
 }

publicvoidredo() throwsCannotRedoException {
super.redo();
try {
synchronized(StringContent.this) {
insertString(offset, string);
string = null;
// Update the Positions that were in the range removed.
if(posRefs != null) {
updateUndoPositions(posRefs);
posRefs = null;
 }
 }
 } catch (BadLocationExceptionbl) {
thrownewCannotRedoException();
 }
 }

// Where the string goes.
protectedintoffset;
// Length of the string.
protectedintlength;
// The string that was inserted. To cut down on space needed this
// will only be valid after an undo.
protectedStringstring;
// An array of instances of UndoPosRef for the Positions in the
// range that was removed, valid after undo.
@SuppressWarnings("rawtypes") // UndoPosRef type cannot be exposed
protectedVectorposRefs;
 }


/**
 * UndoableEdit created for removes.
 */
classRemoveUndoextendsAbstractUndoableEdit {
@SuppressWarnings("unchecked")
protectedRemoveUndo(intoffset, Stringstring) {
super();
this.offset = offset;
this.string = string;
this.length = string.length();
if(marks != null)
posRefs = getPositionsInRange(null, offset, length);
 }

publicvoidundo() throwsCannotUndoException {
super.undo();
try {
synchronized(StringContent.this) {
insertString(offset, string);
// Update the Positions that were in the range removed.
if(posRefs != null) {
updateUndoPositions(posRefs);
posRefs = null;
 }
string = null;
 }
 } catch (BadLocationExceptionbl) {
thrownewCannotUndoException();
 }
 }

@SuppressWarnings("unchecked")
publicvoidredo() throwsCannotRedoException {
super.redo();
try {
synchronized(StringContent.this) {
string = getString(offset, length);
// Get the Positions in the range being removed.
if(marks != null)
posRefs = getPositionsInRange(null, offset, length);
remove(offset, length);
 }
 } catch (BadLocationExceptionbl) {
thrownewCannotRedoException();
 }
 }

// Where the string goes.
protectedintoffset;
// Length of the string.
protectedintlength;
// The string that was inserted. This will be null after an undo.
protectedStringstring;
// An array of instances of UndoPosRef for the Positions in the
// range that was removed, valid before undo.
protectedVector<UndoPosRef> posRefs;
 }
}