gecko-dev/grendel/calypso/util/ByteBuf.java

/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil -*-
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License.  You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is the Grendel mail/news client.
 *
 * The Initial Developer of the Original Code is Netscape Communications
 * Corporation.  Portions created by Netscape are Copyright (C) 1997
 * Netscape Communications Corporation.  All Rights Reserved.
 *
 * Contributors: Edwin Woudt <edwin@woudt.nl>
 */

package calypso.util;

import java.util.*;

import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.RandomAccessFile;

/**
 * This class is similar to java/lang/StringBuffer with the following changes:
 * <UL><LI>Stores bytes, not chars
 * <LI>None of the methods are synchronized
 * <LI>There is no sharing of the character array
 * <LI>Converting to a String requires a copy of the character data
 * <LI>Alloc and Recycle are provided to speed up allocation
 * <LI>A bunch of useful operations are provided (comparisons, etc.)
 * </UL>
 */
public final class ByteBuf {
  private byte value[];
  private int count;

//  static ByteBufRecycler gRecycler;

  /**
   * Constructs an empty String buffer, reusing one from the
   * recycler.
   */
  static synchronized public ByteBuf Alloc() {
      return new ByteBuf();
//    if (gRecycler == null) {
//      gRecycler = new ByteBufRecycler();
//    }
//    return gRecycler.alloc();
  }

  /**
   * Release a ByteBuf to the recycler. It is up to the caller
   * to ensure that buffer is no longer being used otherwise
   * unpredicatable program behavior will result.
   */
  static synchronized public void Recycle(ByteBuf aBuf) {
//    if (gRecycler == null) {
//      gRecycler = new ByteBufRecycler();
//    }
//    gRecycler.recycle(aBuf);
  }

  /**
   * Empty the recycler discarding any cached ByteBuf objects
   */
  static synchronized public void EmptyRecycler() {
//    if (null != gRecycler) {
//      gRecycler = null;
//    }
  }

  static void classFinalize() throws Throwable {
    // Poof! Now we are unloadable even though we have a static
    // variable.
  }

  /**
   * Constructs an empty String buffer.
   */
  public ByteBuf() {
    this(16);
  }

  /**
   * Constructs an empty byte buffer with the specified initial length.
   * @param length  the initial length
   */
  public ByteBuf(int length) {
    value = new byte[length];
  }

  /**
   * Constructs a byte buffer with the specified initial value.
   * @param str the initial value of the buffer
   */
  public ByteBuf(String str) {
    this(str.length() + 16);
    append(str);
  }

  public ByteBuf(byte bytes[], int offset, int length) {
    value = new byte[length];
    System.arraycopy(bytes, offset, value, 0, length);
    count = length;
  }

  /**
   * Returns the length (character count) of the buffer.
   */
  public int length() {
    return count;
  }

  /**
   * Returns the current capacity of the String buffer. The capacity
   * is the amount of storage available for newly inserted
   * characters; beyond which an allocation will occur.
   */
  public int capacity() {
    return value.length;
  }

  /**
   * Ensures that the capacity of the buffer is at least equal to the
   * specified minimum.
   * @param minimumCapacity the minimum desired capacity
   */
  public void ensureCapacity(int minimumCapacity) {
    int maxCapacity = value.length;

    if (minimumCapacity > maxCapacity) {
      int newCapacity = (maxCapacity + 1) * 2;
      if (minimumCapacity > newCapacity) {
        newCapacity = minimumCapacity;
      }

      byte newValue[] = new byte[newCapacity];
      System.arraycopy(value, 0, newValue, 0, count);
      value = newValue;
    }
  }

  /**
   * Sets the length of the String. If the length is reduced, characters
   * are lost. If the length is extended, the values of the new characters
   * are set to 0.
   * @param newLength the new length of the buffer
   * @exception StringIndexOutOfBoundsException  If the length is invalid.
   */
  public void setLength(int newLength) {
    if (newLength < 0) {
      throw new StringIndexOutOfBoundsException(newLength);
    }
    if (count < newLength) {
      ensureCapacity(newLength);
      for (; count < newLength; count++) {
        value[count] = (byte)'\0';
      }
    }
    count = newLength;
  }

  /**
   * Returns the byte at the specified index. An index ranges
   * from 0..length()-1.
   * @param index the index of the desired character
   * @exception StringIndexOutOfBoundsException If the index is invalid.
   */
  public byte byteAt(int index) {
    if ((index < 0) || (index >= count)) {
      throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
  }

  /**
   * Copies the characters of the specified substring (determined by
   * srcBegin and srcEnd) into the character array, starting at the
   * array's dstBegin location. Both srcBegin and srcEnd must be legal
   * indexes into the buffer.
   * @param srcBegin  begin copy at this offset in the String
   * @param srcEnd  stop copying at this offset in the String
   * @param dst   the array to copy the data into
   * @param dstBegin  offset into dst
   * @exception StringIndexOutOfBoundsException If there is an invalid index into the buffer.
   */
  public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
    if ((srcBegin < 0) || (srcBegin >= count)) {
      throw new StringIndexOutOfBoundsException(srcBegin);
    }
    if ((srcEnd < 0) || (srcEnd > count)) {
      throw new StringIndexOutOfBoundsException(srcEnd);
    }
    if (srcBegin < srcEnd) {
      System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }
  }

  /**
   * Changes the byte at the specified index to be ch.
   * @param index the index of the character
   * @param ch    the new character
   * @exception StringIndexOutOfBoundsException If the index is invalid.
   */
  public void setByteAt(int index, byte b) {
    if ((index < 0) || (index >= count)) {
      throw new StringIndexOutOfBoundsException(index);
    }
    value[index] = b;
  }

  /**
   * Appends an object to the end of this buffer.
   * @param obj the object to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(Object obj) {
    return append(String.valueOf(obj));
  }

  /**
   * Appends a String to the end of this buffer.  This just appends one byte
   * per char; it strips off the upper 8 bits.  If you want the localized
   * method of converting chars to bytes, use append(String.getBytes()).
   * @param str the String to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(String str) {
    if (str == null) {
      str = String.valueOf(str);
    }

    int len = str.length();
    ensureCapacity(count + len);
    for (int i=0 ; i<len ; i++) {
      value[count++] = (byte) str.charAt(i);
    }
    return this;
  }

  /**
   * Appends an array of bytes to the end of this buffer.
   * @param str the characters to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(byte str[]) {
    int len = str.length;
    ensureCapacity(count + len);
    System.arraycopy(str, 0, value, count, len);
    count += len;
    return this;
  }

  /**
   * Appends a part of an array of characters to the end of this buffer.
   * @param str the characters to be appended
   * @param offset  where to start
   * @param len the number of characters to add
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(byte str[], int offset, int len) {
    ensureCapacity(count + len);
    System.arraycopy(str, offset, value, count, len);
    count += len;
    return this;
  }

  public ByteBuf append(ByteBuf buf) {
    append(buf.toBytes(), 0, buf.length());
    return this;
  }

  /**
   * Appends a boolean to the end of this buffer.
   * @param b the boolean to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(boolean b) {
    return append(String.valueOf(b));
  }

  /**
   * Appends a byte to the end of this buffer.
   * @param ch  the character to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(byte b) {
    ensureCapacity(count + 1);
    value[count++] = b;
    return this;
  }

  /**
   * Appends an integer to the end of this buffer.
   * @param i the integer to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(int i) {
    return append(String.valueOf(i));
  }

  /**
   * Appends a long to the end of this buffer.
   * @param l the long to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(long l) {
    return append(String.valueOf(l));
  }

  /**
   * Appends a float to the end of this buffer.
   * @param f the float to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(float f) {
    return append(String.valueOf(f));
  }

  /**
   * Appends a double to the end of this buffer.
   * @param d the double to be appended
   * @return  the ByteBuf itself, NOT a new one.
   */
  public ByteBuf append(double d) {
    return append(String.valueOf(d));
  }

  /**
   * Inserts an object into the String buffer.
   * @param offset  the offset at which to insert
   * @param obj   the object to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, Object obj) {
    return insert(offset, String.valueOf(obj));
  }

  /**
   * Inserts a String into the String buffer.
   * @param offset  the offset at which to insert
   * @param str   the String to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, String str) {
    if ((offset < 0) || (offset > count)) {
      throw new StringIndexOutOfBoundsException();
    }
    int len = str.length();
    ensureCapacity(count + len);
    System.arraycopy(value, offset, value, offset + len, count - offset);
    for (int i=0 ; i<len ; i++) {
      value[offset++] = (byte) str.charAt(i);
    }
    count += len;
    return this;
  }

  /**
   * Inserts an array of bytes into the String buffer.
   * @param offset  the offset at which to insert
   * @param str   the characters to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, byte str[]) {
    if ((offset < 0) || (offset > count)) {
      throw new StringIndexOutOfBoundsException();
    }
    int len = str.length;
    ensureCapacity(count + len);
    System.arraycopy(value, offset, value, offset + len, count - offset);
    System.arraycopy(str, 0, value, offset, len);
    count += len;
    return this;
  }

  /**
   * Inserts a boolean into the String buffer.
   * @param offset  the offset at which to insert
   * @param b   the boolean to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, boolean b) {
    return insert(offset, String.valueOf(b));
  }

  /**
   * Inserts a byte into the String buffer.
   * @param offset  the offset at which to insert
   * @param ch    the character to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset invalid.
   */
  public ByteBuf insert(int offset, byte b) {
    ensureCapacity(count + 1);
    System.arraycopy(value, offset, value, offset + 1, count - offset);
    value[offset] = b;
    count += 1;
    return this;
  }

  /**
   * Inserts an integer into the String buffer.
   * @param offset  the offset at which to insert
   * @param i   the integer to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, int i) {
    return insert(offset, String.valueOf(i));
  }

  /**
   * Inserts a long into the String buffer.
   * @param offset  the offset at which to insert
   * @param l   the long to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, long l) {
    return insert(offset, String.valueOf(l));
  }

  /**
   * Inserts a float into the String buffer.
   * @param offset  the offset at which to insert
   * @param f   the float to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, float f) {
    return insert(offset, String.valueOf(f));
  }

  /**
   * Inserts a double into the String buffer.
   * @param offset  the offset at which to insert
   * @param d   the double to insert
   * @return    the ByteBuf itself, NOT a new one.
   * @exception StringIndexOutOfBoundsException If the offset is invalid.
   */
  public ByteBuf insert(int offset, double d) {
    return insert(offset, String.valueOf(d));
  }

  /**
   * Reverse the order of the characters in the String buffer.
   */
  public ByteBuf reverse() {
    int n = count - 1;
    for (int j = (n-1) >> 1; j >= 0; --j) {
      byte temp = value[j];
      value[j] = value[n - j];
      value[n - j] = temp;
    }
    return this;
  }


  /**
   * Converts to a String representing the data in the buffer.
   */
  public String toString() {
    return new String(value, 0, count);
  }

  public byte[] toBytes() {
    return value;
  }


  /**
   * Compares this ByteBuf to another ByteBuf.  Returns true if the
   * other ByteBuf is equal to this ByteBuf; that is, has the same length
   * and the same characters in the same sequence.  Upper case
   * characters are folded to lower case before they are compared.
   *
   * @param anotherString the String to compare this String against
   * @return true if the Strings are equal, ignoring case; false otherwise.
   */
  public boolean equalsIgnoreCase(ByteBuf anotherString) {
    if ((anotherString != null) && (anotherString.count == count)) {
      for (int i = 0; i < count; i++) {
        byte c1 = value[i];
        byte c2 = anotherString.value[i];
        if (c1 != c2) {
          // If characters don't match but case may be ignored,
          // try converting both characters to uppercase.
          // If the results match, then the comparison scan should
          // continue.
          char u1 = Character.toUpperCase((char) c1);
          char u2 = Character.toUpperCase((char) c2);
          if (u1 == u2)
            continue;

          // Unfortunately, conversion to uppercase does not work properly
          // for the Georgian alphabet, which has strange rules about case
          // conversion.  So we need to make one last check before
          // exiting.
          if (Character.toLowerCase(u1) == Character.toLowerCase(u2))
            continue;
          return false;
        }
      }
      return true;
    }
    return false;
  }

  public boolean equals(Object aObject) {
    if (aObject != null) {
      if (aObject instanceof ByteBuf) {
        return equals((ByteBuf) aObject);
      } else if (aObject instanceof String) {
        return equals((String) aObject);
      }
    }
    return false;
  }

  /**
   * Compares this ByteBuf to another ByteBuf.  Returns true if the
   * other ByteBuf is equal to this ByteBuf; that is, has the same length
   * and the same characters in the same sequence.
   *
   * @param anotherString the String to compare this String against
   * @return true if the Strings are equal, ignoring case; false otherwise.
   */
  public boolean equals(ByteBuf anotherString) {
    if ((anotherString != null) && (anotherString.count == count)) {
      for (int i = 0; i < count; i++) {
        byte c1 = value[i];
        byte c2 = anotherString.value[i];
        if (c1 != c2) {
          return false;
        }
      }
      return true;
    }
    return false;
  }

  /**
   * Compares this ByteBuf to another String.  Returns true if the
   * other String is equal to this ByteBuf; that is, has the same length
   * and the same characters in the same sequence.  (No localization is done;
   * if the string doesn't contain 8-bit chars, it won't be equal to this
   * ByteBuf.)
   *
   * @param anotherString the String to compare this String against
   * @return true if the Strings are equal, ignoring case; false otherwise.
   */
  public boolean equals(String anotherString) {
    if ((anotherString != null) && (anotherString.length() == count)) {
      for (int i = 0; i < count; i++) {
        byte c1 = value[i];
        byte c2 = (byte) anotherString.charAt(i);
        if (c1 != c2) {
          return false;
        }
      }
      return true;
    }
    return false;
  }

  /**
    * Tests if two byte regions are equal.
    * <p>
    * If <code>toffset</code> or <code>ooffset</code> is negative, or
    * if <code>toffset</code>+<code>length</code> is greater than the
    * length of this ByteBuf, or if
    * <code>ooffset</code>+<code>length</code> is greater than the
    * length of the argument, then this method returns
    * <code>false</code>.
    *
    * @param   toffset   the starting offset of the subregion in this ByteBuf.
    * @param   other     the other bytes.
    * @param   ooffset   the starting offset of the subregion in the argument.
    * @param   len       the number of bytes to compare.
    * @return  <code>true</code> if the specified subregion of this ByteBuf
    *          exactly matches the specified subregion of the argument;
    *          <code>false</code> otherwise.
    */
  public boolean regionMatches(int toffset, byte other[],
                               int ooffset, int len) {
    return regionMatches(false, toffset, other, ooffset, len);
  }


  /**
    * Tests if two byte regions are equal.
    * <p>
    * If <code>toffset</code> or <code>ooffset</code> is negative, or
    * if <code>toffset</code>+<code>length</code> is greater than the
    * length of this ByteBuf, or if
    * <code>ooffset</code>+<code>length</code> is greater than the
    * length of the argument, then this method returns
    * <code>false</code>.
    *
    * @param   ignoreCase   if <code>true</code>, ignore case when comparing
    *                       bytes (treating them as characters).
    * @param   toffset      the starting offset of the subregion in this
    *                       ByteBuf.
    * @param   other        the other bytes.
    * @param   ooffset      the starting offset of the subregion in the
    *                       argument.
    * @param   len          the number of bytes to compare.
    * @return  <code>true</code> if the specified subregion of this ByteBuf
    *          matches the specified subregion of the argument;
    *          <code>false</code> otherwise. Whether the matching is exact
    *          or case insensitive depends on the <code>ignoreCase</code>
    *          argument.
    */
  public boolean regionMatches(boolean ignoreCase,
                               int toffset,
                               byte other[],
                               int ooffset,
                               int len) {
    /* Lifted (and changed from char to byte) from java.lang.String. */
    byte ta[] = value;
    int to = toffset;
    int tlim = count;
    byte pa[] = other;
    int po = ooffset;
    // Note: toffset, ooffset, or len might be near -1>>>1.
    if ((ooffset < 0) || (toffset < 0) || (toffset > count - len) ||
        (ooffset > other.length - len)) {
      return false;
    }
    while (len-- > 0) {
      byte c1 = ta[to++];
      byte c2 = pa[po++];
      if (c1 == c2)
        continue;
      if (ignoreCase) {
        // If characters don't match but case may be ignored,
        // try converting both characters to uppercase.
        // If the results match, then the comparison scan should
        // continue.
        char u1 = Character.toUpperCase((char) c1);
        char u2 = Character.toUpperCase((char) c2);
        if (u1 == u2)
          continue;
        // Unfortunately, conversion to uppercase does not work properly
        // for the Georgian alphabet, which has strange rules about case
        // conversion.  So we need to make one last check before
        // exiting.
        if (Character.toLowerCase(u1) == Character.toLowerCase(u2))
          continue;
      }
      return false;
    }
    return true;
  }


  public boolean regionMatches(int toffset, ByteBuf other,
                               int ooffset, int len) {
    return regionMatches(false, toffset, other.value, ooffset, len);
  }

  public boolean regionMatches(boolean ignoreCase,
                               int toffset, ByteBuf other,
                               int ooffset, int len) {
    return regionMatches(ignoreCase, toffset, other.value, ooffset, len);
  }


  /**
    * Tests if two byte regions are equal.
    * <p>
    * If <code>toffset</code> or <code>ooffset</code> is negative, or
    * if <code>toffset</code>+<code>length</code> is greater than the
    * length of this ByteBuf, or if
    * <code>ooffset</code>+<code>length</code> is greater than the
    * length of the argument, then this method returns
    * <code>false</code>.
    *
    * @param   toffset   the starting offset of the subregion in this ByteBuf.
    * @param   other     the other String.
    * @param   ooffset   the starting offset of the subregion in the argument.
    * @param   len       the number of bytes/characters to compare.
    * @return  <code>true</code> if the specified subregion of this ByteBuf
    *          exactly matches the specified subregion of the String argument;
    *          <code>false</code> otherwise.
    */
  public boolean regionMatches(int toffset, String other,
                               int ooffset, int len) {
    return regionMatches(false, toffset, other, ooffset, len);
  }


  /**
    * Tests if two byte regions are equal.
    * <p>
    * If <code>toffset</code> or <code>ooffset</code> is negative, or
    * if <code>toffset</code>+<code>length</code> is greater than the
    * length of this ByteBuf, or if
    * <code>ooffset</code>+<code>length</code> is greater than the
    * length of the argument, then this method returns
    * <code>false</code>.
    *
    * @param   ignoreCase   if <code>true</code>, ignore case when comparing
    *                       bytes (treating them as characters).
    * @param   toffset      the starting offset of the subregion in this
    *                       ByteBuf.
    * @param   other        the other String.
    * @param   ooffset      the starting offset of the subregion in the
    *                       String argument.
    * @param   len          the number of bytes to compare.
    * @return  <code>true</code> if the specified subregion of this ByteBuf
    *          matches the specified subregion of the String argument;
    *          <code>false</code> otherwise. Whether the matching is exact
    *          or case insensitive depends on the <code>ignoreCase</code>
    *          argument.
    */
  public boolean regionMatches(boolean ignoreCase,
                               int toffset,
                               String other,
                               int ooffset,
                               int len) {
    /* Lifted (and changed from char to byte) from java.lang.String. */
    byte ta[] = value;
    int to = toffset;
    int tlim = count;
    int po = ooffset;
    // Note: toffset, ooffset, or len might be near -1>>>1.
    if ((ooffset < 0) || (toffset < 0) || (toffset > count - len) ||
        (ooffset > other.length() - len)) {
      return false;
    }
    while (len-- > 0) {
      byte c1 = ta[to++];
      byte c2 = (byte) other.charAt(po++);
      if (c1 == c2)
        continue;
      if (ignoreCase) {
        // If characters don't match but case may be ignored,
        // try converting both characters to uppercase.
        // If the results match, then the comparison scan should
        // continue.
        char u1 = Character.toUpperCase((char) c1);
        char u2 = Character.toUpperCase((char) c2);
        if (u1 == u2)
          continue;
        // Unfortunately, conversion to uppercase does not work properly
        // for the Georgian alphabet, which has strange rules about case
        // conversion.  So we need to make one last check before
        // exiting.
        if (Character.toLowerCase(u1) == Character.toLowerCase(u2))
          continue;
      }
      return false;
    }
    return true;
  }


  public int indexOf(int ch) {
    return indexOf(ch, 0);
  }

  public int indexOf(int ch, int fromIndex) {
    int max = count;
    byte v[] = value;

    if (fromIndex < 0) {
      fromIndex = 0;
    } else if (fromIndex >= count) {
      // Note: fromIndex might be near -1>>>1.
      return -1;
    }
    for (int i = fromIndex ; i < max ; i++) {
      if (v[i] == ch) {
        return i;
      }
    }
    return -1;
  }

  public void remove(int fromIndex) {
    remove(fromIndex, count);
  }

  /**
   * Remove characters from the ByteBuf starting at fromIndex and up
   * to but not including toIndex. If toIndex is beyond the length of
   * the ByteBuf then it is automatically clamped to the end of the
   * ByteBuf. If fromIndex is out of range a StringIndexOutOfBoundsException
   * is thrown.
   */
  public void remove(int fromIndex, int toIndex) {
    if ((fromIndex >= toIndex) || (fromIndex >= count)) {
      throw new StringIndexOutOfBoundsException(fromIndex);
    }
    if (toIndex > count) toIndex = count;
    if (toIndex == count) {
      count = fromIndex;
      return;
    }
    System.arraycopy(value, toIndex, value, fromIndex, count - toIndex);
    count -= toIndex - fromIndex;
  }

  public int toInteger() throws NumberFormatException {
      int result = 0;
      int sign = 1;
      int i = 0;
      if (count == 0) {
          throw new NumberFormatException();
      }
      while (i < count - 1 && (value[i] <= ' ')) {
          i++;
      }
      if (value[i] == '-' && i < count - 1) {
          sign = -1;
          i++;
      }
      do {
          byte b = value[i];
          if (b >= '0' || b <= '9') {
              result = (result * 10) + (b - '0');
          } else {
              throw new NumberFormatException();
          }
          i++;
      } while (i < count && value[i] > ' ');
      while (i < count && value[i] < ' ') {
          i++;
      }
      if (i < count) {
          throw new NumberFormatException();
      }
      return result * sign;
  }

  public ByteBuf trim() {
    int i=0;
    while (i < count && value[i] <= ' ') i++;
    if (i > 0) {
      count -= i;
      System.arraycopy(value, i, value, 0, count);
    }
    while (count > 0 && value[count-1] <= ' ') count--;
    return this;
  }


  /** Write to the given output stream a detailed description of each
    byte in this buffer. */
  public void fullDump(PrintStream out) {
    fullDump(out, 0, count);
  }

  /** Write to the given output stream a detailed description of the given
    bytes in this buffer. */
  public void fullDump(PrintStream out, int start, int end) {
    for (int i=start ; i<end ; i++) {
      out.write(value[i]);
      out.print("(" + ((int) value[i]) + ") ");
    }
    out.println("");
  }

  /** Invokes InputStream.read(), appending the bytes to this Bytebuf.
      @return the number of bytes read, or -1 if eof.
    */
  public int read(InputStream file, int max_bytes)
    throws IOException {
    ensureCapacity(count + max_bytes);
    int i = file.read(value, count, max_bytes);
    if (i > 0) count += i;
    return i;
  }

  /** Invokes RandomAccessFile.read(), appending the bytes to this Bytebuf.
      (A RandomAccessFile is not an InputStream, because Java is a crock.)
      @return the number of bytes read, or -1 if eof.
    */
  public int read(RandomAccessFile file, int max_bytes)
    throws IOException {
    ensureCapacity(count + max_bytes);
    int i = file.read(value, count, max_bytes);
    if (i > 0) count += i;
    return i;
  }

  /** Writes the contents to the given output stream. */
  public void write(OutputStream out) throws IOException {
    out.write(value, 0, count);
  }

  /** Writes the contents to the given RandomAccessFile. */
  public void write(RandomAccessFile out) throws IOException {
    out.write(value, 0, count);
  }

  /** Creates a new InputStream whose content is this ByteBuf.  Note that
   changing the ByteBuf can affect the stream; the data is <i>not</i>
   copied. */
  public InputStream makeInputStream() {
    return new ByteArrayInputStream(value, 0, count);
  }
}