src/com/ibm/richtext/styledtext/CharBuffer.java - external/github.com/unicode-org/icu - Git at Google

 /*
  * (C) Copyright IBM Corp. 1998-2004.  All Rights Reserved.
  *
  * The program is provided "as is" without any warranty express or
  * implied, including the warranty of non-infringement and the implied
  * warranties of merchantibility and fitness for a particular purpose.
  * IBM will not be liable for any damages suffered by you as a result
  * of using the Program. In no event will IBM be liable for any
  * special, indirect or consequential damages or lost profits even if
  * IBM has been advised of the possibility of their occurrence. IBM
  * will not be liable for any third party claims against you.
  */
 /** An implementation of MCharBuffer that stores chars in an array with an insertion gap. */
 /*
     Change history
     072396 jf   - fixed a bug in replace(int, int, char[], int, int) so that it correctly
                 inserted into the middle of the buffer.
     080296 jf   - added timestamp.  This is strictly a debugging device to help catch
                 stale iterators.

     082296 jbr  added check for 0-length iterator in replace
 */

 package com.ibm.richtext.styledtext;

 import java.io.Externalizable;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
 import java.io.IOException;

 import java.text.CharacterIterator;

 final class CharBuffer
     extends MCharBuffer implements Externalizable
 {

     static final String COPYRIGHT =
                 "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
   private static final int kGrowSize = 0x80; // small size for testing
   private static final int CURRENT_VERSION = 1; // version code for streaming
   private static final long serialVersionUID = 563174;

   transient Validation fValidation = null;
   private char[] fArray;
   transient private int fArraySize;
   transient private int fGap;

   /** Create an empty char buffer. */
   public CharBuffer()
   {
   }

   /** Create a char buffer that can hold at least capacity chars. */

   public CharBuffer(int capacity)
   {
     fArray = allocate(capacity);
   }

   public void readExternal(ObjectInput in) throws IOException,
                                             ClassNotFoundException {

     if (in.readInt() != CURRENT_VERSION) {
         throw new IOException("Invalid version of CharBuffer");
     }

     fArray = (char[]) in.readObject();
     if (fArray != null) {
         fArraySize = fArray.length;
         fGap = fArraySize;
     }
     else {
         fArraySize = 0;
         fGap = 0;
     }
   }

   public void writeExternal(ObjectOutput out) throws IOException {

     compress();
     out.writeInt(CURRENT_VERSION);
     out.writeObject(fArray);
   }

   private void invalidate() {

     if (fValidation != null) {
         fValidation.invalidate();
         fValidation = null;
     }
   }

   // not ThreadSafe - could end up with two Validations
   // being generated
   private Validation getValidation() {

     if (fValidation == null) {
         fValidation = new Validation();
     }
     return fValidation;
   }

   /** Replace the chars from start to limit with the chars from srcStart to srcLimit in srcBuffer. */

   /** Replace the chars from start to limit with the chars from srcStart to srcLimit in srcChars.
   * This is the core routine for manipulating the buffer.
   */
   public void replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit)
   {
     invalidate();
     int dstLength = limit - start;
     int srcLength = srcLimit - srcStart;

     if (dstLength < 0 || srcLength < 0) {
         throw new IllegalArgumentException("replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit)");
     }

     int gapAlloc = 0;
     if (srcChars == null) {
         gapAlloc = srcLength;
         srcLength = 0;
     }

     int newSize = fArraySize - dstLength + srcLength;

     if (fArray == null) {
         if (start != 0 || limit != 0) {
             throw new IllegalArgumentException("replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit)");
         }
         if (newSize + gapAlloc > 0) {
             fArray = allocate(newSize + gapAlloc);
             if (srcLength > 0) {
                 System.arraycopy(srcChars, srcStart, fArray, 0, srcLength);
                 fArraySize = srcLength;
                 fGap = srcLength;
             }
         }
     } else {
         int newGap = start + srcLength;
         int gapLimit = fArray.length - fArraySize + fGap;

         if (newSize + gapAlloc > fArray.length) {
             char[] temp = allocate(newSize + gapAlloc);

             //move stuff at beginning that we aren't writing over
             if (start > 0) {
                 at(0, start, temp, 0);
             }
             //move stuff from src array that we are copying
             if (srcLength > 0) {
                 System.arraycopy(srcChars, srcStart, temp, start, srcLength);
             }
             //move stuff at end that we aren't copying over
             if (limit < fArraySize) {
                 at(limit, fArraySize, temp, temp.length - newSize + newGap);
             //change 7-23-96
             //    at(limit, fArraySize - limit, temp, temp.length - newSize + newGap);
             }

             fArray = temp;
         } else {
             if (start > fGap) {
                 System.arraycopy(fArray, gapLimit, fArray, fGap, start - fGap);
             }
             if (limit < fGap) {
                 System.arraycopy(fArray, limit, fArray, fArray.length - newSize + newGap, fGap - limit);
             }
             if (srcLength > 0) {
                 System.arraycopy(srcChars, srcStart, fArray, start, srcLength);
             }
         }

         fArraySize = newSize;
         fGap = newGap;
     }
   }

   /** Replace the chars from start to limit with the chars from srcStart to srcLimit in srcString. */

   /* This implements optimizations for null text or inserting text that fits at the gap,
      and defaults to call the core replace routine if these optimizations fail. */

   public void replace(int start, int limit, String srcString, int srcStart, int srcLimit)
   {
     invalidate();
     int length = limit - start;
     int srcLength = srcLimit - srcStart;

     if (fArray == null) {
         if (start != 0 || limit != 0) {
             throw new IllegalArgumentException("replace(int start, int limit, String srcString, int srcStart, int srcLimit)");
         }
         if (srcLength > 0) {
             fArray = allocate(srcLength);
             srcString.getChars(srcStart, srcLimit, fArray, 0);
             fArraySize = srcLength;
             fGap = srcLength;
         }
     } else {
         if (start == fGap && fArray.length >= fArraySize - length + srcLength) {
             if (srcLimit > 0) {
                 srcString.getChars(srcStart, srcLimit, fArray, fGap);
                 fGap += srcLength;
             }
             fArraySize += srcLength - length;
         } else {
             replace(start, limit, srcString != null ? srcString.toCharArray() : null, srcStart, srcLimit);
         }
     }
   }

   public void replace(int start, int limit, MConstText srcText, int srcStart, int srcLimit)
   {
     invalidate();
     int length = limit - start;
     int srcLength = srcLimit - srcStart;

     if (fArray == null) {
         if (start != 0 || limit != 0) {
             throw new IllegalArgumentException("replace(int start, int limit, String srcString, int srcStart, int srcLimit)");
         }
         if (srcLength > 0) {
             fArray = allocate(srcLength);
             srcText.extractChars(srcStart, srcLimit, fArray, 0);
             fArraySize = srcLength;
             fGap = srcLength;
         }
     } else {
         if (start == fGap && fArray.length >= fArraySize - length + srcLength) {
             if (srcLimit > 0) {
                 srcText.extractChars(srcStart, srcLimit, fArray, fGap);
                 fGap += srcLength;
             }
             fArraySize += srcLength - length;
         } else {
             char[] temp = srcLength == 0? null : new char[srcLength];
             if (temp != null) {
                 srcText.extractChars(srcStart, srcLimit, temp, 0);
             }
             replace(start, limit, temp, 0, srcLimit - srcStart);
         }
     }
   }

   /** Replace the chars from start to limit with srcChar. */

   /* This implements optimizations for null text or replacing a character that fits into the gap,
      and defaults to call the core replace routine if these optimizations fail. */

   public void replace(int start, int limit, char srcChar)
   {
     invalidate();
     if (fArray == null) {
         if (start != 0 || limit != 0) {
             throw new IllegalArgumentException("replace(int start, int limit, char srcChar)");
         }
         fArray = allocate(1);
         fArray[0] = srcChar;
         fArraySize = 1;
         fGap = 1;
     } else {
         int length = limit - start;
         if (start == fGap && fArray.length > fArraySize - length) {
             fArray[fGap] = srcChar;
             fGap += 1;
             fArraySize += 1 - length;
         } else {
             replace(start, limit, new char[] { srcChar} , 0, 1);
         }
     }
   }

   /** Return the char at pos. */

   public char at(int pos)
   {
     if (pos < 0 || pos >= fArraySize) {
       throw new IllegalArgumentException();
     }
     return pos < fGap ? fArray[pos] : fArray[fArray.length - fArraySize + pos];
   }

   /** Copy the chars from start to limit to dst starting at dstStart. */

   public void at(int start, int limit, char[] dst, int dstStart)
   {
     int length = limit - start;

     if (start < 0 || limit < start || limit > fArraySize) {
         throw new IllegalArgumentException();
     }

     if (limit <= fGap) {
         System.arraycopy(fArray, start, dst, dstStart, length);
     } else if (start >= fGap) {
         System.arraycopy(fArray, fArray.length - fArraySize + start, dst, dstStart, length);
     } else {
         System.arraycopy(fArray, start, dst, dstStart, fGap - start);
         System.arraycopy(fArray, fArray.length - fArraySize + fGap, dst, dstStart + fGap - start, limit - fGap);
     }
   }

   /** Return the number of chars in the buffer. */

   public final int length()
   {
     return fArraySize;
   }

   /** Return the number of chars the buffer can hold before it must reallocate. */

   public final int capacity()
   {
     return fArray != null ? fArray.length : 0;
   }

   /** Reserve capacity chars at start. Utility to optimize a sequence of operations at start. */

   public void reserveCapacity(int start, int capacity)
   {
     replace(start, start, (char[])null, 0, capacity);
   }

   /** Minimize the storage used by the buffer. */

   public void compress()
   {
     invalidate();
     if (fArraySize == 0) {
         fArray = null;
         fGap = 0;
     } else if (fArraySize != fArray.length) {
         char[] temp = new char[fArraySize];
         at(0, fArraySize, temp, 0);
         fArray = temp;
         fGap = fArraySize;
     }
   }

   /** Display the buffer. */

   public String toString()
   {
     if (fArray != null) {
         return new StringBuffer()
         .append("limit: ").append(fArray.length)
         .append(", size: ").append(fArraySize)
         .append(", gap: ").append(fGap)
         .append(", ").append(fArray, 0, fGap)
         .append(fArray, fArray.length - fArraySize + fGap, fArraySize - fGap)
         .toString();
     } else {
         return new String("The buffer is empty.");
     }
   }

   public CharacterIterator createCharacterIterator(int start, int limit) {

     Validation val = getValidation();
     return new CharBufferIterator(start, limit, fArray, fArraySize, fGap, val);
   }

   /** The resizing algorithm. Return a value >= minSize. */

   protected int allocation(int minSize)
   {
     //    return (minSize + kGrowSize) & ~(kGrowSize - 1);
     return minSize < kGrowSize ? kGrowSize : (minSize * 2 + kGrowSize) & ~(kGrowSize - 1);
   }

   /** Allocate a new character array of limit >= minSize. */

   protected char[] allocate(int minSize)
   {
     return new char[allocation(minSize)];
   }
 }
	/*
	* (C) Copyright IBM Corp. 1998-2004. All Rights Reserved.
	*
	* The program is provided "as is" without any warranty express or
	* implied, including the warranty of non-infringement and the implied
	* warranties of merchantibility and fitness for a particular purpose.
	* IBM will not be liable for any damages suffered by you as a result
	* of using the Program. In no event will IBM be liable for any
	* special, indirect or consequential damages or lost profits even if
	* IBM has been advised of the possibility of their occurrence. IBM
	* will not be liable for any third party claims against you.
	*/
	/** An implementation of MCharBuffer that stores chars in an array with an insertion gap. */
	/*
	Change history
	072396 jf - fixed a bug in replace(int, int, char[], int, int) so that it correctly
	inserted into the middle of the buffer.
	080296 jf - added timestamp. This is strictly a debugging device to help catch
	stale iterators.

	082296 jbr added check for 0-length iterator in replace
	*/

	package com.ibm.richtext.styledtext;

	import java.io.Externalizable;
	import java.io.ObjectInput;
	import java.io.ObjectOutput;
	import java.io.IOException;

	import java.text.CharacterIterator;

	final class CharBuffer
	extends MCharBuffer implements Externalizable
	{

	static final String COPYRIGHT =
	"(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
	private static final int kGrowSize = 0x80; // small size for testing
	private static final int CURRENT_VERSION = 1; // version code for streaming
	private static final long serialVersionUID = 563174;

	transient Validation fValidation = null;
	private char[] fArray;
	transient private int fArraySize;
	transient private int fGap;

	/** Create an empty char buffer. */
	public CharBuffer()
	{
	}

	/** Create a char buffer that can hold at least capacity chars. */

	public CharBuffer(int capacity)
	{
	fArray = allocate(capacity);
	}

	public void readExternal(ObjectInput in) throws IOException,
	ClassNotFoundException {

	if (in.readInt() != CURRENT_VERSION) {
	throw new IOException("Invalid version of CharBuffer");
	}

	fArray = (char[]) in.readObject();
	if (fArray != null) {
	fArraySize = fArray.length;
	fGap = fArraySize;
	}
	else {
	fArraySize = 0;
	fGap = 0;
	}
	}

	public void writeExternal(ObjectOutput out) throws IOException {

	compress();
	out.writeInt(CURRENT_VERSION);
	out.writeObject(fArray);
	}

	private void invalidate() {

	if (fValidation != null) {
	fValidation.invalidate();
	fValidation = null;
	}
	}

	// not ThreadSafe - could end up with two Validations
	// being generated
	private Validation getValidation() {

	if (fValidation == null) {
	fValidation = new Validation();
	}
	return fValidation;
	}

	/** Replace the chars from start to limit with the chars from srcStart to srcLimit in srcBuffer. */

	/** Replace the chars from start to limit with the chars from srcStart to srcLimit in srcChars.
	* This is the core routine for manipulating the buffer.
	*/
	public void replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit)
	{
	invalidate();
	int dstLength = limit - start;
	int srcLength = srcLimit - srcStart;

	if (dstLength < 0 \|\| srcLength < 0) {
	throw new IllegalArgumentException("replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit)");
	}

	int gapAlloc = 0;
	if (srcChars == null) {
	gapAlloc = srcLength;
	srcLength = 0;
	}

	int newSize = fArraySize - dstLength + srcLength;

	if (fArray == null) {
	if (start != 0 \|\| limit != 0) {
	throw new IllegalArgumentException("replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit)");
	}
	if (newSize + gapAlloc > 0) {
	fArray = allocate(newSize + gapAlloc);
	if (srcLength > 0) {
	System.arraycopy(srcChars, srcStart, fArray, 0, srcLength);
	fArraySize = srcLength;
	fGap = srcLength;
	}
	}
	} else {
	int newGap = start + srcLength;
	int gapLimit = fArray.length - fArraySize + fGap;

	if (newSize + gapAlloc > fArray.length) {
	char[] temp = allocate(newSize + gapAlloc);

	//move stuff at beginning that we aren't writing over
	if (start > 0) {
	at(0, start, temp, 0);
	}
	//move stuff from src array that we are copying
	if (srcLength > 0) {
	System.arraycopy(srcChars, srcStart, temp, start, srcLength);
	}
	//move stuff at end that we aren't copying over
	if (limit < fArraySize) {
	at(limit, fArraySize, temp, temp.length - newSize + newGap);
	//change 7-23-96
	// at(limit, fArraySize - limit, temp, temp.length - newSize + newGap);
	}

	fArray = temp;
	} else {
	if (start > fGap) {
	System.arraycopy(fArray, gapLimit, fArray, fGap, start - fGap);
	}
	if (limit < fGap) {
	System.arraycopy(fArray, limit, fArray, fArray.length - newSize + newGap, fGap - limit);
	}
	if (srcLength > 0) {
	System.arraycopy(srcChars, srcStart, fArray, start, srcLength);
	}
	}

	fArraySize = newSize;
	fGap = newGap;
	}
	}

	/** Replace the chars from start to limit with the chars from srcStart to srcLimit in srcString. */

	/* This implements optimizations for null text or inserting text that fits at the gap,
	and defaults to call the core replace routine if these optimizations fail. */

	public void replace(int start, int limit, String srcString, int srcStart, int srcLimit)
	{
	invalidate();
	int length = limit - start;
	int srcLength = srcLimit - srcStart;

	if (fArray == null) {
	if (start != 0 \|\| limit != 0) {
	throw new IllegalArgumentException("replace(int start, int limit, String srcString, int srcStart, int srcLimit)");
	}
	if (srcLength > 0) {
	fArray = allocate(srcLength);
	srcString.getChars(srcStart, srcLimit, fArray, 0);
	fArraySize = srcLength;
	fGap = srcLength;
	}
	} else {
	if (start == fGap && fArray.length >= fArraySize - length + srcLength) {
	if (srcLimit > 0) {
	srcString.getChars(srcStart, srcLimit, fArray, fGap);
	fGap += srcLength;
	}
	fArraySize += srcLength - length;
	} else {
	replace(start, limit, srcString != null ? srcString.toCharArray() : null, srcStart, srcLimit);
	}
	}
	}

	public void replace(int start, int limit, MConstText srcText, int srcStart, int srcLimit)
	{
	invalidate();
	int length = limit - start;
	int srcLength = srcLimit - srcStart;

	if (fArray == null) {
	if (start != 0 \|\| limit != 0) {
	throw new IllegalArgumentException("replace(int start, int limit, String srcString, int srcStart, int srcLimit)");
	}
	if (srcLength > 0) {
	fArray = allocate(srcLength);
	srcText.extractChars(srcStart, srcLimit, fArray, 0);
	fArraySize = srcLength;
	fGap = srcLength;
	}
	} else {
	if (start == fGap && fArray.length >= fArraySize - length + srcLength) {
	if (srcLimit > 0) {
	srcText.extractChars(srcStart, srcLimit, fArray, fGap);
	fGap += srcLength;
	}
	fArraySize += srcLength - length;
	} else {
	char[] temp = srcLength == 0? null : new char[srcLength];
	if (temp != null) {
	srcText.extractChars(srcStart, srcLimit, temp, 0);
	}
	replace(start, limit, temp, 0, srcLimit - srcStart);
	}
	}
	}

	/** Replace the chars from start to limit with srcChar. */

	/* This implements optimizations for null text or replacing a character that fits into the gap,
	and defaults to call the core replace routine if these optimizations fail. */

	public void replace(int start, int limit, char srcChar)
	{
	invalidate();
	if (fArray == null) {
	if (start != 0 \|\| limit != 0) {
	throw new IllegalArgumentException("replace(int start, int limit, char srcChar)");
	}
	fArray = allocate(1);
	fArray[0] = srcChar;
	fArraySize = 1;
	fGap = 1;
	} else {
	int length = limit - start;
	if (start == fGap && fArray.length > fArraySize - length) {
	fArray[fGap] = srcChar;
	fGap += 1;
	fArraySize += 1 - length;
	} else {
	replace(start, limit, new char[] { srcChar} , 0, 1);
	}
	}
	}

	/** Return the char at pos. */

	public char at(int pos)
	{
	if (pos < 0 \|\| pos >= fArraySize) {
	throw new IllegalArgumentException();
	}
	return pos < fGap ? fArray[pos] : fArray[fArray.length - fArraySize + pos];
	}

	/** Copy the chars from start to limit to dst starting at dstStart. */

	public void at(int start, int limit, char[] dst, int dstStart)
	{
	int length = limit - start;

	if (start < 0 \|\| limit < start \|\| limit > fArraySize) {
	throw new IllegalArgumentException();
	}

	if (limit <= fGap) {
	System.arraycopy(fArray, start, dst, dstStart, length);
	} else if (start >= fGap) {
	System.arraycopy(fArray, fArray.length - fArraySize + start, dst, dstStart, length);
	} else {
	System.arraycopy(fArray, start, dst, dstStart, fGap - start);
	System.arraycopy(fArray, fArray.length - fArraySize + fGap, dst, dstStart + fGap - start, limit - fGap);
	}
	}

	/** Return the number of chars in the buffer. */

	public final int length()
	{
	return fArraySize;
	}

	/** Return the number of chars the buffer can hold before it must reallocate. */

	public final int capacity()
	{
	return fArray != null ? fArray.length : 0;
	}

	/** Reserve capacity chars at start. Utility to optimize a sequence of operations at start. */

	public void reserveCapacity(int start, int capacity)
	{
	replace(start, start, (char[])null, 0, capacity);
	}

	/** Minimize the storage used by the buffer. */

	public void compress()
	{
	invalidate();
	if (fArraySize == 0) {
	fArray = null;
	fGap = 0;
	} else if (fArraySize != fArray.length) {
	char[] temp = new char[fArraySize];
	at(0, fArraySize, temp, 0);
	fArray = temp;
	fGap = fArraySize;
	}
	}

	/** Display the buffer. */

	public String toString()
	{
	if (fArray != null) {
	return new StringBuffer()
	.append("limit: ").append(fArray.length)
	.append(", size: ").append(fArraySize)
	.append(", gap: ").append(fGap)
	.append(", ").append(fArray, 0, fGap)
	.append(fArray, fArray.length - fArraySize + fGap, fArraySize - fGap)
	.toString();
	} else {
	return new String("The buffer is empty.");
	}
	}

	public CharacterIterator createCharacterIterator(int start, int limit) {

	Validation val = getValidation();
	return new CharBufferIterator(start, limit, fArray, fArraySize, fGap, val);
	}

	/** The resizing algorithm. Return a value >= minSize. */

	protected int allocation(int minSize)
	{
	// return (minSize + kGrowSize) & ~(kGrowSize - 1);
	return minSize < kGrowSize ? kGrowSize : (minSize * 2 + kGrowSize) & ~(kGrowSize - 1);
	}

	/** Allocate a new character array of limit >= minSize. */

	protected char[] allocate(int minSize)
	{
	return new char[allocation(minSize)];
	}
	}