--- a/src/org/eclipse/jetty/io/AbstractBuffer.java	Sat Oct 22 23:00:57 2016 -0600
+++ b/src/org/eclipse/jetty/io/AbstractBuffer.java	Sun Oct 23 02:42:05 2016 -0600
@@ -33,696 +33,696 @@
  */
 public abstract class AbstractBuffer implements Buffer
 {
-    private static final Logger LOG = LoggerFactory.getLogger(AbstractBuffer.class);
+	private static final Logger LOG = LoggerFactory.getLogger(AbstractBuffer.class);
 
-    private final static boolean __boundsChecking = Boolean.getBoolean("org.eclipse.jetty.io.AbstractBuffer.boundsChecking");
-    
-    protected final static String 
-    __IMMUTABLE = "IMMUTABLE", 
-    __READONLY = "READONLY",
-    __READWRITE = "READWRITE", 
-    __VOLATILE = "VOLATILE";
-    
-    protected int _access;
-    protected boolean _volatile;
+	private final static boolean __boundsChecking = Boolean.getBoolean("org.eclipse.jetty.io.AbstractBuffer.boundsChecking");
+	
+	protected final static String 
+	__IMMUTABLE = "IMMUTABLE", 
+	__READONLY = "READONLY",
+	__READWRITE = "READWRITE", 
+	__VOLATILE = "VOLATILE";
+	
+	protected int _access;
+	protected boolean _volatile;
 
-    protected int _get;
-    protected int _put;
-    protected int _hash;
-    protected int _hashGet;
-    protected int _hashPut;
-    protected int _mark;
-    protected String _string;
-    protected View _view;
+	protected int _get;
+	protected int _put;
+	protected int _hash;
+	protected int _hashGet;
+	protected int _hashPut;
+	protected int _mark;
+	protected String _string;
+	protected View _view;
 
-    /**
-     * Constructor for BufferView
-     * 
-     * @param access 0==IMMUTABLE, 1==READONLY, 2==READWRITE
-     */
-    public AbstractBuffer(int access, boolean isVolatile)
-    {
-        if (access == IMMUTABLE && isVolatile)
-                throw new IllegalArgumentException("IMMUTABLE && VOLATILE");
-        setMarkIndex(-1);
-        _access = access;
-        _volatile = isVolatile;
-    }
+	/**
+	 * Constructor for BufferView
+	 * 
+	 * @param access 0==IMMUTABLE, 1==READONLY, 2==READWRITE
+	 */
+	public AbstractBuffer(int access, boolean isVolatile)
+	{
+		if (access == IMMUTABLE && isVolatile)
+				throw new IllegalArgumentException("IMMUTABLE && VOLATILE");
+		setMarkIndex(-1);
+		_access = access;
+		_volatile = isVolatile;
+	}
 
-    /*
-     * @see org.eclipse.io.Buffer#toArray()
-     */
-    public byte[] asArray()
-    {
-        byte[] bytes = new byte[length()];
-        byte[] array = array();
-        if (array != null)
-            System.arraycopy(array, getIndex(), bytes, 0, bytes.length);
-        else
-            peek(getIndex(), bytes, 0, length());
-        return bytes;
-    }
+	/*
+	 * @see org.eclipse.io.Buffer#toArray()
+	 */
+	public byte[] asArray()
+	{
+		byte[] bytes = new byte[length()];
+		byte[] array = array();
+		if (array != null)
+			System.arraycopy(array, getIndex(), bytes, 0, bytes.length);
+		else
+			peek(getIndex(), bytes, 0, length());
+		return bytes;
+	}
 
-    public ByteArrayBuffer duplicate(int access)
-    {
-        Buffer b=this.buffer();
-        if (this instanceof Buffer.CaseInsensitve || b instanceof Buffer.CaseInsensitve)
-            return new ByteArrayBuffer.CaseInsensitive(asArray(), 0, length(),access);
-        else
-            return new ByteArrayBuffer(asArray(), 0, length(), access);
-    }
-    
-    /*
-     * @see org.eclipse.io.Buffer#asNonVolatile()
-     */
-    public Buffer asNonVolatileBuffer()
-    {
-        if (!isVolatile()) return this;
-        return duplicate(_access);
-    }
+	private ByteArrayBuffer duplicate(int access)
+	{
+		Buffer b=this.buffer();
+		if (this instanceof Buffer.CaseInsensitve || b instanceof Buffer.CaseInsensitve)
+			return new ByteArrayBuffer.CaseInsensitive(asArray(), 0, length(),access);
+		else
+			return new ByteArrayBuffer(asArray(), 0, length(), access);
+	}
+	
+	/*
+	 * @see org.eclipse.io.Buffer#asNonVolatile()
+	 */
+	public Buffer asNonVolatileBuffer()
+	{
+		if (!isVolatile()) return this;
+		return duplicate(_access);
+	}
 
-    public Buffer asImmutableBuffer()
-    {
-        if (isImmutable()) return this;
-        return duplicate(IMMUTABLE);
-    }
+	public Buffer asImmutableBuffer()
+	{
+		if (isImmutable()) return this;
+		return duplicate(IMMUTABLE);
+	}
 
-    /*
-     * @see org.eclipse.util.Buffer#asReadOnlyBuffer()
-     */
-    public Buffer asReadOnlyBuffer()
-    {
-        if (isReadOnly()) return this;
-        return new View(this, markIndex(), getIndex(), putIndex(), READONLY);
-    }
+	/*
+	 * @see org.eclipse.util.Buffer#asReadOnlyBuffer()
+	 */
+	public Buffer asReadOnlyBuffer()
+	{
+		if (isReadOnly()) return this;
+		return new View(this, markIndex(), getIndex(), putIndex(), READONLY);
+	}
 
-    public Buffer asMutableBuffer()
-    {
-        if (!isImmutable()) return this;
-        
-        Buffer b=this.buffer();
-        if (b.isReadOnly())
-        {
-            return duplicate(READWRITE);
-        }
-        return new View(b, markIndex(), getIndex(), putIndex(), _access);
-    }
+	public Buffer asMutableBuffer()
+	{
+		if (!isImmutable()) return this;
+		
+		Buffer b=this.buffer();
+		if (b.isReadOnly())
+		{
+			return duplicate(READWRITE);
+		}
+		return new View(b, markIndex(), getIndex(), putIndex(), _access);
+	}
 
-    public Buffer buffer()
-    {
-        return this;
-    }
+	public Buffer buffer()
+	{
+		return this;
+	}
 
-    public void clear()
-    {
-        setMarkIndex(-1);
-        setGetIndex(0);
-        setPutIndex(0);
-    }
+	public void clear()
+	{
+		setMarkIndex(-1);
+		setGetIndex(0);
+		setPutIndex(0);
+	}
 
-    public void compact()
-    {
-        if (isReadOnly()) throw new IllegalStateException(__READONLY);
-        int s = markIndex() >= 0 ? markIndex() : getIndex();
-        if (s > 0)
-        {
-            byte array[] = array();
-            int length = putIndex() - s;
-            if (length > 0)
-            {
-                if (array != null)
-                    System.arraycopy(array(), s, array(), 0, length);
-                else
-                    poke(0, peek(s, length));
-            }
-            if (markIndex() > 0) setMarkIndex(markIndex() - s);
-            setGetIndex(getIndex() - s);
-            setPutIndex(putIndex() - s);
-        }
-    }
+	public void compact()
+	{
+		if (isReadOnly()) throw new IllegalStateException(__READONLY);
+		int s = markIndex() >= 0 ? markIndex() : getIndex();
+		if (s > 0)
+		{
+			byte array[] = array();
+			int length = putIndex() - s;
+			if (length > 0)
+			{
+				if (array != null)
+					System.arraycopy(array(), s, array(), 0, length);
+				else
+					poke(0, peek(s, length));
+			}
+			if (markIndex() > 0) setMarkIndex(markIndex() - s);
+			setGetIndex(getIndex() - s);
+			setPutIndex(putIndex() - s);
+		}
+	}
 
-    @Override
-    public boolean equals(Object obj)
-    {
-        if (obj==this)
-            return true;
-        
-        // reject non buffers;
-        if (obj == null || !(obj instanceof Buffer)) return false;
-        Buffer b = (Buffer) obj;
+	@Override
+	public boolean equals(Object obj)
+	{
+		if (obj==this)
+			return true;
+		
+		// reject non buffers;
+		if (obj == null || !(obj instanceof Buffer)) return false;
+		Buffer b = (Buffer) obj;
 
-        if (this instanceof Buffer.CaseInsensitve ||  b instanceof Buffer.CaseInsensitve)
-            return equalsIgnoreCase(b);
-        
-        // reject different lengths
-        if (b.length() != length()) return false;
+		if (this instanceof Buffer.CaseInsensitve ||  b instanceof Buffer.CaseInsensitve)
+			return equalsIgnoreCase(b);
+		
+		// reject different lengths
+		if (b.length() != length()) return false;
 
-        // reject AbstractBuffer with different hash value
-        if (_hash != 0 && obj instanceof AbstractBuffer)
-        {
-            AbstractBuffer ab = (AbstractBuffer) obj;
-            if (ab._hash != 0 && _hash != ab._hash) return false;
-        }
+		// reject AbstractBuffer with different hash value
+		if (_hash != 0 && obj instanceof AbstractBuffer)
+		{
+			AbstractBuffer ab = (AbstractBuffer) obj;
+			if (ab._hash != 0 && _hash != ab._hash) return false;
+		}
 
-        // Nothing for it but to do the hard grind.
-        int get=getIndex();
-        int bi=b.putIndex();
-        for (int i = putIndex(); i-->get;)
-        {
-            byte b1 = peek(i);
-            byte b2 = b.peek(--bi);
-            if (b1 != b2) return false;
-        }
-        return true;
-    }
+		// Nothing for it but to do the hard grind.
+		int get=getIndex();
+		int bi=b.putIndex();
+		for (int i = putIndex(); i-->get;)
+		{
+			byte b1 = peek(i);
+			byte b2 = b.peek(--bi);
+			if (b1 != b2) return false;
+		}
+		return true;
+	}
 
-    public boolean equalsIgnoreCase(Buffer b)
-    {
-        if (b==this)
-            return true;
-        
-        // reject different lengths
-        if (b.length() != length()) return false;
+	public boolean equalsIgnoreCase(Buffer b)
+	{
+		if (b==this)
+			return true;
+		
+		// reject different lengths
+		if (b.length() != length()) return false;
 
-        // reject AbstractBuffer with different hash value
-        if (_hash != 0 && b instanceof AbstractBuffer)
-        {
-            AbstractBuffer ab = (AbstractBuffer) b;
-            if (ab._hash != 0 && _hash != ab._hash) return false;
-        }
+		// reject AbstractBuffer with different hash value
+		if (_hash != 0 && b instanceof AbstractBuffer)
+		{
+			AbstractBuffer ab = (AbstractBuffer) b;
+			if (ab._hash != 0 && _hash != ab._hash) return false;
+		}
 
-        // Nothing for it but to do the hard grind.
-        int get=getIndex();
-        int bi=b.putIndex();
-        
-        byte[] array = array();
-        byte[] barray= b.array();
-        if (array!=null && barray!=null)
-        {
-            for (int i = putIndex(); i-->get;)
-            {
-                byte b1 = array[i];
-                byte b2 = barray[--bi];
-                if (b1 != b2)
-                {
-                    if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A');
-                    if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A');
-                    if (b1 != b2) return false;
-                }
-            }
-        }
-        else
-        {
-            for (int i = putIndex(); i-->get;)
-            {
-                byte b1 = peek(i);
-                byte b2 = b.peek(--bi);
-                if (b1 != b2)
-                {
-                    if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A');
-                    if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A');
-                    if (b1 != b2) return false;
-                }
-            }
-        }
-        return true;
-    }
+		// Nothing for it but to do the hard grind.
+		int get=getIndex();
+		int bi=b.putIndex();
+		
+		byte[] array = array();
+		byte[] barray= b.array();
+		if (array!=null && barray!=null)
+		{
+			for (int i = putIndex(); i-->get;)
+			{
+				byte b1 = array[i];
+				byte b2 = barray[--bi];
+				if (b1 != b2)
+				{
+					if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A');
+					if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A');
+					if (b1 != b2) return false;
+				}
+			}
+		}
+		else
+		{
+			for (int i = putIndex(); i-->get;)
+			{
+				byte b1 = peek(i);
+				byte b2 = b.peek(--bi);
+				if (b1 != b2)
+				{
+					if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A');
+					if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A');
+					if (b1 != b2) return false;
+				}
+			}
+		}
+		return true;
+	}
 
-    public byte get()
-    {
-        return peek(_get++);
-    }
+	public byte get()
+	{
+		return peek(_get++);
+	}
 
-    public int get(byte[] b, int offset, int length)
-    {
-        int gi = getIndex();
-        int l=length();
-        if (l==0)
-            return -1;
-        
-        if (length>l)
-            length=l;
-        
-        length = peek(gi, b, offset, length);
-        if (length>0)
-            setGetIndex(gi + length);
-        return length;
-    }
+	public int get(byte[] b, int offset, int length)
+	{
+		int gi = getIndex();
+		int l=length();
+		if (l==0)
+			return -1;
+		
+		if (length>l)
+			length=l;
+		
+		length = peek(gi, b, offset, length);
+		if (length>0)
+			setGetIndex(gi + length);
+		return length;
+	}
 
-    public Buffer get(int length)
-    {
-        int gi = getIndex();
-        Buffer view = peek(gi, length);
-        setGetIndex(gi + length);
-        return view;
-    }
+	public Buffer get(int length)
+	{
+		int gi = getIndex();
+		Buffer view = peek(gi, length);
+		setGetIndex(gi + length);
+		return view;
+	}
 
-    public final int getIndex()
-    {
-        return _get;
-    }
+	public final int getIndex()
+	{
+		return _get;
+	}
 
-    public boolean hasContent()
-    {
-        return _put > _get;
-    }
-    
-    @Override
-    public int hashCode()
-    {
-        if (_hash == 0 || _hashGet!=_get || _hashPut!=_put) 
-        {
-            int get=getIndex();
-            byte[] array = array();
-            if (array==null)
-            {
-                for (int i = putIndex(); i-- >get;)
-                {
-                    byte b = peek(i);
-                    if ('a' <= b && b <= 'z') 
-                        b = (byte) (b - 'a' + 'A');
-                    _hash = 31 * _hash + b;
-                }
-            }
-            else
-            {
-                for (int i = putIndex(); i-- >get;)
-                {
-                    byte b = array[i];
-                    if ('a' <= b && b <= 'z') 
-                        b = (byte) (b - 'a' + 'A');
-                    _hash = 31 * _hash + b;
-                }
-            }
-            if (_hash == 0) 
-                _hash = -1;
-            _hashGet=_get;
-            _hashPut=_put;
-            
-        }
-        return _hash;
-    }
+	public boolean hasContent()
+	{
+		return _put > _get;
+	}
+	
+	@Override
+	public int hashCode()
+	{
+		if (_hash == 0 || _hashGet!=_get || _hashPut!=_put) 
+		{
+			int get=getIndex();
+			byte[] array = array();
+			if (array==null)
+			{
+				for (int i = putIndex(); i-- >get;)
+				{
+					byte b = peek(i);
+					if ('a' <= b && b <= 'z') 
+						b = (byte) (b - 'a' + 'A');
+					_hash = 31 * _hash + b;
+				}
+			}
+			else
+			{
+				for (int i = putIndex(); i-- >get;)
+				{
+					byte b = array[i];
+					if ('a' <= b && b <= 'z') 
+						b = (byte) (b - 'a' + 'A');
+					_hash = 31 * _hash + b;
+				}
+			}
+			if (_hash == 0) 
+				_hash = -1;
+			_hashGet=_get;
+			_hashPut=_put;
+			
+		}
+		return _hash;
+	}
 
-    public boolean isImmutable()
-    {
-        return _access <= IMMUTABLE;
-    }
+	public boolean isImmutable()
+	{
+		return _access <= IMMUTABLE;
+	}
 
-    public boolean isReadOnly()
-    {
-        return _access <= READONLY;
-    }
+	public boolean isReadOnly()
+	{
+		return _access <= READONLY;
+	}
 
-    public boolean isVolatile()
-    {
-        return _volatile;
-    }
+	public boolean isVolatile()
+	{
+		return _volatile;
+	}
 
-    public int length()
-    {
-        return _put - _get;
-    }
+	public int length()
+	{
+		return _put - _get;
+	}
 
-    public void mark()
-    {
-        setMarkIndex(_get - 1);
-    }
+	public void mark()
+	{
+		setMarkIndex(_get - 1);
+	}
 
-    public void mark(int offset)
-    {
-        setMarkIndex(_get + offset);
-    }
+	public void mark(int offset)
+	{
+		setMarkIndex(_get + offset);
+	}
 
-    public int markIndex()
-    {
-        return _mark;
-    }
+	public int markIndex()
+	{
+		return _mark;
+	}
 
-    public byte peek()
-    {
-        return peek(_get);
-    }
+	public byte peek()
+	{
+		return peek(_get);
+	}
 
-    public Buffer peek(int index, int length)
-    {
-        if (_view == null)
-        {
-            _view = new View(this, -1, index, index + length, isReadOnly() ? READONLY : READWRITE);
-        }
-        else
-        {
-            _view.update(this.buffer());
-            _view.setMarkIndex(-1);
-            _view.setGetIndex(0);
-            _view.setPutIndex(index + length);
-            _view.setGetIndex(index);
-            
-        }
-        return _view;
-    }
+	public Buffer peek(int index, int length)
+	{
+		if (_view == null)
+		{
+			_view = new View(this, -1, index, index + length, isReadOnly() ? READONLY : READWRITE);
+		}
+		else
+		{
+			_view.update(this.buffer());
+			_view.setMarkIndex(-1);
+			_view.setGetIndex(0);
+			_view.setPutIndex(index + length);
+			_view.setGetIndex(index);
+			
+		}
+		return _view;
+	}
 
-    public int poke(int index, Buffer src)
-    {
-        _hash=0;
-        /* 
-        if (isReadOnly()) 
-            throw new IllegalStateException(__READONLY);
-        if (index < 0) 
-            throw new IllegalArgumentException("index<0: " + index + "<0");
-        */
-        
-        int length=src.length();
-        if (index + length > capacity())
-        {
-            length=capacity()-index;
-            /*
-            if (length<0)
-                throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity());
-            */
-        }
-        
-        byte[] src_array = src.array();
-        byte[] dst_array = array();
-        if (src_array != null && dst_array != null)
-            System.arraycopy(src_array, src.getIndex(), dst_array, index, length);
-        else if (src_array != null)
-        {
-            int s=src.getIndex();
-            for (int i=0;i<length;i++)
-                poke(index++,src_array[s++]);
-        }
-        else if (dst_array != null)
-        {
-            int s=src.getIndex();
-            for (int i=0;i<length;i++)
-                dst_array[index++]=src.peek(s++);
-        }
-        else
-        {
-            int s=src.getIndex();
-            for (int i=0;i<length;i++)
-                poke(index++,src.peek(s++));
-        }
-        
-        return length;
-    }
-    
+	public int poke(int index, Buffer src)
+	{
+		_hash=0;
+		/* 
+		if (isReadOnly()) 
+			throw new IllegalStateException(__READONLY);
+		if (index < 0) 
+			throw new IllegalArgumentException("index<0: " + index + "<0");
+		*/
+		
+		int length=src.length();
+		if (index + length > capacity())
+		{
+			length=capacity()-index;
+			/*
+			if (length<0)
+				throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity());
+			*/
+		}
+		
+		byte[] src_array = src.array();
+		byte[] dst_array = array();
+		if (src_array != null && dst_array != null)
+			System.arraycopy(src_array, src.getIndex(), dst_array, index, length);
+		else if (src_array != null)
+		{
+			int s=src.getIndex();
+			for (int i=0;i<length;i++)
+				poke(index++,src_array[s++]);
+		}
+		else if (dst_array != null)
+		{
+			int s=src.getIndex();
+			for (int i=0;i<length;i++)
+				dst_array[index++]=src.peek(s++);
+		}
+		else
+		{
+			int s=src.getIndex();
+			for (int i=0;i<length;i++)
+				poke(index++,src.peek(s++));
+		}
+		
+		return length;
+	}
+	
 
-    public int poke(int index, byte[] b, int offset, int length)
-    {
-        _hash=0;
-        /*
-        if (isReadOnly()) 
-            throw new IllegalStateException(__READONLY);
-        if (index < 0) 
-            throw new IllegalArgumentException("index<0: " + index + "<0");
-        */
-        if (index + length > capacity())
-        {
-            length=capacity()-index;
-            /* if (length<0)
-                throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity());
-            */
-        }
-        
-        byte[] dst_array = array();
-        if (dst_array != null)
-            System.arraycopy(b, offset, dst_array, index, length);
-        else
-        {
-            int s=offset;
-            for (int i=0;i<length;i++)
-                poke(index++,b[s++]);
-        }
-        return length;
-    }
+	public int poke(int index, byte[] b, int offset, int length)
+	{
+		_hash=0;
+		/*
+		if (isReadOnly()) 
+			throw new IllegalStateException(__READONLY);
+		if (index < 0) 
+			throw new IllegalArgumentException("index<0: " + index + "<0");
+		*/
+		if (index + length > capacity())
+		{
+			length=capacity()-index;
+			/* if (length<0)
+				throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity());
+			*/
+		}
+		
+		byte[] dst_array = array();
+		if (dst_array != null)
+			System.arraycopy(b, offset, dst_array, index, length);
+		else
+		{
+			int s=offset;
+			for (int i=0;i<length;i++)
+				poke(index++,b[s++]);
+		}
+		return length;
+	}
 
-    public int put(Buffer src)
-    {
-        int pi = putIndex();
-        int l=poke(pi, src);
-        setPutIndex(pi + l);
-        return l;
-    }
+	public int put(Buffer src)
+	{
+		int pi = putIndex();
+		int l=poke(pi, src);
+		setPutIndex(pi + l);
+		return l;
+	}
 
-    public void put(byte b)
-    {
-        int pi = putIndex();
-        poke(pi, b);
-        setPutIndex(pi + 1);
-    }
+	public void put(byte b)
+	{
+		int pi = putIndex();
+		poke(pi, b);
+		setPutIndex(pi + 1);
+	}
 
-    public int put(byte[] b, int offset, int length)
-    {
-        int pi = putIndex();
-        int l = poke(pi, b, offset, length);
-        setPutIndex(pi + l);
-        return l;
-    }
-    
-    public int put(byte[] b)
-    {
-        int pi = putIndex();
-        int l = poke(pi, b, 0, b.length);
-        setPutIndex(pi + l);
-        return l;
-    }
+	public int put(byte[] b, int offset, int length)
+	{
+		int pi = putIndex();
+		int l = poke(pi, b, offset, length);
+		setPutIndex(pi + l);
+		return l;
+	}
+	
+	public int put(byte[] b)
+	{
+		int pi = putIndex();
+		int l = poke(pi, b, 0, b.length);
+		setPutIndex(pi + l);
+		return l;
+	}
 
-    public final int putIndex()
-    {
-        return _put;
-    }
+	public final int putIndex()
+	{
+		return _put;
+	}
 
-    public void reset()
-    {
-        if (markIndex() >= 0) setGetIndex(markIndex());
-    }
+	public void reset()
+	{
+		if (markIndex() >= 0) setGetIndex(markIndex());
+	}
 
-    public void rewind()
-    {
-        setGetIndex(0);
-        setMarkIndex(-1);
-    }
+	public void rewind()
+	{
+		setGetIndex(0);
+		setMarkIndex(-1);
+	}
 
-    public void setGetIndex(int getIndex)
-    {
-        /* bounds checking
-        if (isImmutable()) 
-            throw new IllegalStateException(__IMMUTABLE);
-        if (getIndex < 0)
-            throw new IllegalArgumentException("getIndex<0: " + getIndex + "<0");
-        if (getIndex > putIndex())
-            throw new IllegalArgumentException("getIndex>putIndex: " + getIndex + ">" + putIndex());
-         */
-        _get = getIndex;
-        _hash=0;
-    }
+	public void setGetIndex(int getIndex)
+	{
+		/* bounds checking
+		if (isImmutable()) 
+			throw new IllegalStateException(__IMMUTABLE);
+		if (getIndex < 0)
+			throw new IllegalArgumentException("getIndex<0: " + getIndex + "<0");
+		if (getIndex > putIndex())
+			throw new IllegalArgumentException("getIndex>putIndex: " + getIndex + ">" + putIndex());
+		 */
+		_get = getIndex;
+		_hash=0;
+	}
 
-    public void setMarkIndex(int index)
-    {
-        /*
-        if (index>=0 && isImmutable()) 
-            throw new IllegalStateException(__IMMUTABLE);
-        */
-        _mark = index;
-    }
+	public void setMarkIndex(int index)
+	{
+		/*
+		if (index>=0 && isImmutable()) 
+			throw new IllegalStateException(__IMMUTABLE);
+		*/
+		_mark = index;
+	}
 
-    public void setPutIndex(int putIndex)
-    {
-        /* bounds checking
-        if (isImmutable()) 
-            throw new IllegalStateException(__IMMUTABLE);
-        if (putIndex > capacity())
-                throw new IllegalArgumentException("putIndex>capacity: " + putIndex + ">" + capacity());
-        if (getIndex() > putIndex)
-                throw new IllegalArgumentException("getIndex>putIndex: " + getIndex() + ">" + putIndex);
-         */
-        _put = putIndex;
-        _hash=0;
-    }
+	public void setPutIndex(int putIndex)
+	{
+		/* bounds checking
+		if (isImmutable()) 
+			throw new IllegalStateException(__IMMUTABLE);
+		if (putIndex > capacity())
+				throw new IllegalArgumentException("putIndex>capacity: " + putIndex + ">" + capacity());
+		if (getIndex() > putIndex)
+				throw new IllegalArgumentException("getIndex>putIndex: " + getIndex() + ">" + putIndex);
+		 */
+		_put = putIndex;
+		_hash=0;
+	}
 
-    public int skip(int n)
-    {
-        if (length() < n) n = length();
-        setGetIndex(getIndex() + n);
-        return n;
-    }
+	public int skip(int n)
+	{
+		if (length() < n) n = length();
+		setGetIndex(getIndex() + n);
+		return n;
+	}
 
-    public Buffer slice()
-    {
-        return peek(getIndex(), length());
-    }
+	public Buffer slice()
+	{
+		return peek(getIndex(), length());
+	}
 
-    public Buffer sliceFromMark()
-    {
-        return sliceFromMark(getIndex() - markIndex() - 1);
-    }
+	public Buffer sliceFromMark()
+	{
+		return sliceFromMark(getIndex() - markIndex() - 1);
+	}
 
-    public Buffer sliceFromMark(int length)
-    {
-        if (markIndex() < 0) return null;
-        Buffer view = peek(markIndex(), length);
-        setMarkIndex(-1);
-        return view;
-    }
+	public Buffer sliceFromMark(int length)
+	{
+		if (markIndex() < 0) return null;
+		Buffer view = peek(markIndex(), length);
+		setMarkIndex(-1);
+		return view;
+	}
 
-    public int space()
-    {
-        return capacity() - _put;
-    }
+	public int space()
+	{
+		return capacity() - _put;
+	}
 
-    public String toDetailString()
-    {
-        StringBuilder buf = new StringBuilder();
-        buf.append("[");
-        buf.append(super.hashCode());
-        buf.append(",");
-        buf.append(this.buffer().hashCode());
-        buf.append(",m=");
-        buf.append(markIndex());
-        buf.append(",g=");
-        buf.append(getIndex());
-        buf.append(",p=");
-        buf.append(putIndex());
-        buf.append(",c=");
-        buf.append(capacity());
-        buf.append("]={");
-        if (markIndex() >= 0)
-        {
-            for (int i = markIndex(); i < getIndex(); i++)
-            {
-                byte b =  peek(i);
-                TypeUtil.toHex(b,buf);
-            }
-            buf.append("}{");
-        }
-        int count = 0;
-        for (int i = getIndex(); i < putIndex(); i++)
-        {
-            byte b =  peek(i);
-            TypeUtil.toHex(b,buf);
-            if (count++ == 50)
-            {
-                if (putIndex() - i > 20)
-                {
-                    buf.append(" ... ");
-                    i = putIndex() - 20;
-                }
-            }
-        }
-        buf.append('}');
-        return buf.toString();
-    }
+	public String toDetailString()
+	{
+		StringBuilder buf = new StringBuilder();
+		buf.append("[");
+		buf.append(super.hashCode());
+		buf.append(",");
+		buf.append(this.buffer().hashCode());
+		buf.append(",m=");
+		buf.append(markIndex());
+		buf.append(",g=");
+		buf.append(getIndex());
+		buf.append(",p=");
+		buf.append(putIndex());
+		buf.append(",c=");
+		buf.append(capacity());
+		buf.append("]={");
+		if (markIndex() >= 0)
+		{
+			for (int i = markIndex(); i < getIndex(); i++)
+			{
+				byte b =  peek(i);
+				TypeUtil.toHex(b,buf);
+			}
+			buf.append("}{");
+		}
+		int count = 0;
+		for (int i = getIndex(); i < putIndex(); i++)
+		{
+			byte b =  peek(i);
+			TypeUtil.toHex(b,buf);
+			if (count++ == 50)
+			{
+				if (putIndex() - i > 20)
+				{
+					buf.append(" ... ");
+					i = putIndex() - 20;
+				}
+			}
+		}
+		buf.append('}');
+		return buf.toString();
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public String toString()
-    {
-        if (isImmutable())
-        {
-            if (_string == null) 
-                _string = new String(asArray(), 0, length());
-            return _string;
-        }
-        return new String(asArray(), 0, length());
-    }
+	/* ------------------------------------------------------------ */
+	@Override
+	public String toString()
+	{
+		if (isImmutable())
+		{
+			if (_string == null) 
+				_string = new String(asArray(), 0, length());
+			return _string;
+		}
+		return new String(asArray(), 0, length());
+	}
 
-    /* ------------------------------------------------------------ */
-    public String toString(String charset)
-    {
-        try
-        {
-            byte[] bytes=array();
-            if (bytes!=null)
-                return new String(bytes,getIndex(),length(),charset);
-            return new String(asArray(), 0, length(),charset);
-            
-        }
-        catch(Exception e)
-        {
-            LOG.warn("",e);
-            return new String(asArray(), 0, length());
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public String toString(String charset)
+	{
+		try
+		{
+			byte[] bytes=array();
+			if (bytes!=null)
+				return new String(bytes,getIndex(),length(),charset);
+			return new String(asArray(), 0, length(),charset);
+			
+		}
+		catch(Exception e)
+		{
+			LOG.warn("",e);
+			return new String(asArray(), 0, length());
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public String toString(Charset charset)
-    {
-        try
-        {
-            byte[] bytes=array();
-            if (bytes!=null)
-                return new String(bytes,getIndex(),length(),charset);
-            return new String(asArray(), 0, length(),charset);
-        }
-        catch(Exception e)
-        {
-            LOG.warn("",e);
-            return new String(asArray(), 0, length());
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public String toString(Charset charset)
+	{
+		try
+		{
+			byte[] bytes=array();
+			if (bytes!=null)
+				return new String(bytes,getIndex(),length(),charset);
+			return new String(asArray(), 0, length(),charset);
+		}
+		catch(Exception e)
+		{
+			LOG.warn("",e);
+			return new String(asArray(), 0, length());
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public String toDebugString()
-    {
-        return getClass()+"@"+super.hashCode();
-    }
+	/* ------------------------------------------------------------ */
+	public String toDebugString()
+	{
+		return getClass()+"@"+super.hashCode();
+	}
 
-    /* ------------------------------------------------------------ */
-    public void writeTo(OutputStream out)
-    	throws IOException
-    {
-        byte[] array = array();
-        
-        if (array!=null)
-        {
-            out.write(array,getIndex(),length());
-        }
-        else
-        {
-            int len = this.length();
-            byte[] buf=new byte[len>1024?1024:len];
-            int offset=_get;
-            while (len>0)
-            {
-                int l=peek(offset,buf,0,len>buf.length?buf.length:len);
-                out.write(buf,0,l);
-                offset+=l;
-                len-=l;
-            }
-        } 
-        clear();
-    }
-    
-    /* ------------------------------------------------------------ */
-    public int readFrom(InputStream in,int max) throws IOException
-    {
-        byte[] array = array();
-        int s=space();
-        if (s>max)
-            s=max;
+	/* ------------------------------------------------------------ */
+	public void writeTo(OutputStream out)
+		throws IOException
+	{
+		byte[] array = array();
+		
+		if (array!=null)
+		{
+			out.write(array,getIndex(),length());
+		}
+		else
+		{
+			int len = this.length();
+			byte[] buf=new byte[len>1024?1024:len];
+			int offset=_get;
+			while (len>0)
+			{
+				int l=peek(offset,buf,0,len>buf.length?buf.length:len);
+				out.write(buf,0,l);
+				offset+=l;
+				len-=l;
+			}
+		} 
+		clear();
+	}
+	
+	/* ------------------------------------------------------------ */
+	public int readFrom(InputStream in,int max) throws IOException
+	{
+		byte[] array = array();
+		int s=space();
+		if (s>max)
+			s=max;
 
-        if (array!=null)
-        {
-            int l=in.read(array,_put,s);
-            if (l>0)
-                _put+=l;
-            return l;
-        }
-        else
-        {
-            byte[] buf=new byte[s>1024?1024:s];
-            int total=0;
-            while (s>0)
-            {
-                int l=in.read(buf,0,buf.length);
-                if (l<0)
-                    return total>0?total:-1;
-                int p=put(buf,0,l);
-                assert l==p;
-                s-=l;
-            }
-            return total; 
-        }
-    }
+		if (array!=null)
+		{
+			int l=in.read(array,_put,s);
+			if (l>0)
+				_put+=l;
+			return l;
+		}
+		else
+		{
+			byte[] buf=new byte[s>1024?1024:s];
+			int total=0;
+			while (s>0)
+			{
+				int l=in.read(buf,0,buf.length);
+				if (l<0)
+					return total>0?total:-1;
+				int p=put(buf,0,l);
+				assert l==p;
+				s-=l;
+			}
+			return total; 
+		}
+	}
 }