org.jgroups.blocks.GridOutputStream Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of wildfly-client-all

This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up with different versions on classes on the class path).

There is a newer version: 34.0.0.Final

Show newest version

package org.jgroups.blocks;

import org.jgroups.logging.Log;
import org.jgroups.logging.LogFactory;
import org.jgroups.annotations.Experimental;

import java.io.*;

/**
 * @author Bela Ban
 */
@Experimental
public class GridOutputStream extends OutputStream {
    final ReplCache cache;
    final short                    repl_count;
    final int                      chunk_size;
    final String                   name;
    protected final GridFile       file; // file representing this output stream
    int                            index=0;                // index into the file for writing
    int                            local_index=0;
    final byte[]                   current_buffer;
    static final Log               log=LogFactory.getLog(GridOutputStream.class);
    

    
    GridOutputStream(GridFile file, boolean append, ReplCache cache,
                     short repl_count, int chunk_size) throws FileNotFoundException {
        this.file=file;
        this.name=file.getPath();
        this.cache=cache;
        this.repl_count=repl_count;
        this.chunk_size=chunk_size;
        current_buffer=new byte[chunk_size];
    }




    public void write(int b) throws IOException {
        int remaining=getBytesRemainingInChunk();
        if(remaining == 0) {
            flush();
            local_index=0;
            remaining=chunk_size;
        }
        current_buffer[local_index]=(byte)b;
        local_index++;
        index++;
    }


    public void write(byte[] b) throws IOException {
        if(b != null)
            write(b, 0, b.length);
    }



    public void write(byte[] b, int off, int len) throws IOException {
        while(len > 0) {
            int remaining=getBytesRemainingInChunk();
            if(remaining == 0) {
                flush();
                local_index=0;
                remaining=chunk_size;
            }
            int bytes_to_write=Math.min(remaining, len);
            System.arraycopy(b, off, current_buffer, local_index, bytes_to_write);
            off+=bytes_to_write;
            len-=bytes_to_write;
            local_index+=bytes_to_write;
            index+=bytes_to_write;
        }
    }


    public void close() throws IOException {
        flush();
        reset();
    }

    public void flush() throws IOException {
        int chunk_number=getChunkNumber();
        String key=name + ".#" + chunk_number;
        byte[] val=new byte[local_index];
        System.arraycopy(current_buffer, 0, val, 0, local_index);
        cache.put(key, val, repl_count, 0);
        if(log.isTraceEnabled())
            log.trace("put(): index=" + index + ", key=" + key + ": " + val.length + " bytes");
        file.setLength(index);
    }

    private int getBytesRemainingInChunk() {
        return chunk_size - local_index;
    }



    private int getChunkNumber() {
        return (index-1) / chunk_size;
    }

    private void reset() {
        index=local_index=0;
    }


 
}