Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //
  //  ========================================================================
  //  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
  //  ------------------------------------------------------------------------
  //  All rights reserved. This program and the accompanying materials
  //  are made available under the terms of the Eclipse Public License v1.0
  //  and Apache License v2.0 which accompanies this distribution.
  //
  //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //
 
 package org.eclipse.jetty.io;
 
 
 
 public abstract class AbstractBuffer implements Buffer
 {
     private static final Logger LOG = Log.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;
 
     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

Parameters:
access 0==IMMUTABLE, 1==READONLY, 2==READWRITE
 
     public AbstractBuffer(int accessboolean isVolatile)
     {
         if (access ==  && isVolatile)
                 throw new IllegalArgumentException("IMMUTABLE && VOLATILE");
         setMarkIndex(-1);
          = access;
          = isVolatile;
     }
 
     /*
      * @see org.eclipse.io.Buffer#toArray()
      */
     public byte[] asArray()
     {
         byte[] bytes = new byte[length()];
         byte[] array = array();
         if (array != null)
             System.arraycopy(arraygetIndex(), 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();
    }
    public Buffer asImmutableBuffer()
    {
        if (isImmutable()) return this;
        return duplicate();
    }
    /*
     * @see org.eclipse.util.Buffer#asReadOnlyBuffer()
     */
    public Buffer asReadOnlyBuffer()
    {
        if (isReadOnly()) return this;
        return new View(thismarkIndex(), getIndex(), putIndex(), );
    }
    public Buffer asMutableBuffer()
    {
        if (!isImmutable()) return this;
        
        Buffer b=this.buffer();
        if (b.isReadOnly())
        {
            return duplicate();
        }
        return new View(bmarkIndex(), getIndex(), putIndex(), );
    }
    public Buffer buffer()
    {
        return this;
    }
    public void clear()
    {
        setMarkIndex(-1);
        setGetIndex(0);
        setPutIndex(0);
    }
    public void compact()
    {
        if (isReadOnly()) throw new IllegalStateException();
        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(), sarray(), 0, length);
                else
                    poke(0, peek(slength));
            }
            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 = (Bufferobj;
        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 ( != 0 && obj instanceof AbstractBuffer)
        {
            AbstractBuffer ab = (AbstractBufferobj;
            if (ab._hash != 0 &&  != ab._hashreturn 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 != b2return false;
        }
        return true;
    }
    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 ( != 0 && b instanceof AbstractBuffer)
        {
            AbstractBuffer ab = (AbstractBufferb;
            if (ab._hash != 0 &&  != ab._hashreturn false;
        }
        // Nothing for it but to do the hard grind.
        int get=getIndex();
        int bi=b.putIndex();
        
        byte[] array = array();
        byte[] barrayb.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 != b2return 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 != b2return false;
                }
            }
        }
        return true;
    }
    public byte get()
    {
        return peek(++);
    }
    public int get(byte[] bint offsetint length)
    {
        int gi = getIndex();
        int l=length();
        if (l==0)
            return -1;
        
        if (length>l)
            length=l;
        
        length = peek(giboffsetlength);
        if (length>0)
            setGetIndex(gi + length);
        return length;
    }
    public Buffer get(int length)
    {
        int gi = getIndex();
        Buffer view = peek(gilength);
        setGetIndex(gi + length);
        return view;
    }
    public final int getIndex()
    {
        return ;
    }
    public boolean hasContent()
    {
        return  > ;
    }
    
    @Override
    public int hashCode()
    {
        if ( == 0 || != || !=
        {
            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');
                     = 31 *  + b;
                }
            }
            else
            {
                for (int i = putIndex(); i-- >get;)
                {
                    byte b = array[i];
                    if ('a' <= b && b <= 'z'
                        b = (byte) (b - 'a' + 'A');
                     = 31 *  + b;
                }
            }
            if ( == 0) 
                 = -1;
            =;
            =;
            
        }
        return ;
    }
    public boolean isImmutable()
    {
        return  <= ;
    }
    public boolean isReadOnly()
    {
        return  <= ;
    }
    public boolean isVolatile()
    {
        return ;
    }
    public int length()
    {
        return  - ;
    }
    public void mark()
    {
        setMarkIndex( - 1);
    }
    public void mark(int offset)
    {
        setMarkIndex( + offset);
    }
    public int markIndex()
    {
        return ;
    }
    public byte peek()
    {
        return peek();
    }
    public Buffer peek(int indexint length)
    {
        if ( == null)
        {
             = new View(this, -1, indexindex + lengthisReadOnly() ?  : );
        }
        else
        {
            .update(this.buffer());
            .setMarkIndex(-1);
            .setGetIndex(0);
            .setPutIndex(index + length);
            .setGetIndex(index);
            
        }
        return ;
    }
    public int poke(int indexBuffer src)
    {
        =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_arraysrc.getIndex(), dst_arrayindexlength);
        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 indexbyte[] bint offsetint length)
    {
        =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(boffsetdst_arrayindexlength);
        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(pisrc);
        setPutIndex(pi + l);
        return l;
    }
    public void put(byte b)
    {
        int pi = putIndex();
        poke(pib);
        setPutIndex(pi + 1);
    }
    public int put(byte[] bint offsetint length)
    {
        int pi = putIndex();
        int l = poke(piboffsetlength);
        setPutIndex(pi + l);
        return l;
    }
    
    public int put(byte[] b)
    {
        int pi = putIndex();
        int l = poke(pib, 0, b.length);
        setPutIndex(pi + l);
        return l;
    }
    public final int putIndex()
    {
        return ;
    }
    public void reset()
    {
        if (markIndex() >= 0) setGetIndex(markIndex());
    }
    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());
         */
         = getIndex;
        =0;
    }
    public void setMarkIndex(int index)
    {
        /*
        if (index>=0 && isImmutable()) 
            throw new IllegalStateException(__IMMUTABLE);
        */
         = 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);
         */
         = putIndex;
        =0;
    }
    public int skip(int n)
    {
        if (length() < nn = length();
        setGetIndex(getIndex() + n);
        return n;
    }
    public Buffer slice()
    {
        return peek(getIndex(), length());
    }
    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 int space()
    {
        return capacity() - ;
    }
    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 ( == null
                 = new String(asArray(), 0, length());
            return ;
        }
        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)
        {
            .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)
        {
            .warn(e);
            return new String(asArray(), 0, length());
        }
    }
    /* ------------------------------------------------------------ */
    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=;
            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 maxthrows IOException
    {
        byte[] array = array();
        int s=space();
        if (s>max)
            s=max;
        if (array!=null)
        {
            int l=in.read(array,,s);
            if (l>0)
                +=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
        }
    }
New to GrepCode? Check out our FAQ X