Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.io;
 
 

Buffer to access streams.

 
 public class Buffer {
     public static final int DEFAULT_SIZE = 8192;
 
     private final byte[] buffer;

    
Create a Buffer with UTF-8 encoding
 
     public Buffer() {
         this();
     }
 
     public Buffer(int bufferSize) {
         this. = new byte[bufferSize];
     }
 
     public Buffer(Buffer orig) {
         this(orig.buffer.length);
     }
 
     //--
     
     public int size() {
         return .;
     }
     
     public int fill(InputStream inthrows IOException {
         return fill(in, 0, .null);
     }
 
     public int fill(InputStream inboolean[] eofthrows IOException {
         return fill(in, 0, .eof);
     }
 
     public static int fill(InputStream inbyte[] bufferthrows IOException {
         return fill(inbuffer, 0, buffer.lengthnull);
     }
 
     public static int fill(InputStream inbyte[] bufferint startint maxboolean[] eofthrows IOException {
         int chunk;
         int ofs;
         
         for (ofs = 0; ofs < maxofs += chunk) {
             chunk = in.read(bufferofsmax - ofs);
             if (chunk < 0) {
                 if (eof != null) {
                     eof[0] = true;
                 }
                 return ofs;
             }
         }
         return ofs;
     }
 
     public boolean diff(Buffer cmpint length) {
         for (int i = 0; i < lengthi++) {
             if ([i] != cmp.buffer[i]) {
                 return true;
             }
         }
         return false;
     }
 
     //--
     
     public void digest(InputStream srcMessageDigest digestthrows IOException {
         int numRead;
         
         while (true) {
             numRead = src.read();
            if (numRead < 0) {
                break;
            }
            digest.update(, 0, numRead);
        }
    }
    //--
    public byte[] readBytes(InputStream srcthrows IOException {
        ByteArrayOutputStream dest;
        
        dest = new ByteArrayOutputStream();
        copy(srcdest);
        return dest.toByteArray();
    }
    public String readLine(InputStream srcString encodingthrows IOException {
        ByteArrayOutputStream tmp;
        int c;
        
        tmp = new ByteArrayOutputStream();
        while (true) {
            c = src.read();
            if (c < 0) {
                if (tmp.size() > 0) {
                    throw new EOFException();
                }
                return null;
            } else if (c == '\n') {
                return tmp.toString(encoding);
            } else {
                tmp.write(c);
            }
        }
    }
    
    public String readString(InputStream srcString encodingthrows IOException {
        byte[] bytes;
        
        bytes = readBytes(src);
        return new String(bytesencoding);
    }
    
    
Copies all bytes.

Returns:
number of bytes actually copied
    public int copy(InputStream inNode destthrows IOException {
        OutputStream out;
        int result;
        
        out = dest.createOutputStream();
        result = copy(inout);
        out.close();
        return result;
    }
    
    
Copies all bytes.

Returns:
number of bytes actually copied
    public int copy(InputStream inOutputStream outthrows IOException {
        return copy(inout.);
    }
    
    
Copies up to max bytes.

Returns:
number of bytes actually copied
    public int copy(InputStream inOutputStream outint maxthrows IOException {
        int chunk;
        int all;
        int remaining;
        
        remaining = max;
        all = 0;
        while (remaining > 0) {
            chunk = in.read(, 0, Math.min(remaining.));
            if (chunk < 0) {
                break;
            }
            out.write(, 0, chunk);
            all += chunk;
            remaining -= chunk;
        }
        out.flush();
        return all;
    }
New to GrepCode? Check out our FAQ X