com.nothome.delta.GDiffWriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javaxdelta Show documentation
javaxdelta - Patch generator and patch tool using the GDIFF algorithm
There is a newer version: 1.5
/* 
 *
 * Copyright (c) 2001 Torgeir Veimo
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 */

package com.nothome.delta;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * Outputs a diff following the GDIFF file specification available at
 * http://www.w3.org/TR/NOTE-gdiff-19970901.html.
 */
public class GDiffWriter implements DiffWriter, AutoCloseable {
    
    /**
     * Max length of a chunk.
     */
    public static final int CHUNK_SIZE = Short.MAX_VALUE;
    
    /** The Constant EOF. */
    public static final byte EOF = 0;
    
    /**
     * Max length for single length data encode.
     */
    public static final int DATA_MAX = 246;
    
    /** The Constant DATA_USHORT. */
    public static final int DATA_USHORT = 247;
    
    /** The Constant DATA_INT. */
    public static final int DATA_INT = 248;
    
    /** The Constant COPY_USHORT_UBYTE. */
    public static final int COPY_USHORT_UBYTE = 249;
    
    /** The Constant COPY_USHORT_USHORT. */
    public static final int COPY_USHORT_USHORT = 250;
    
    /** The Constant COPY_USHORT_INT. */
    public static final int COPY_USHORT_INT = 251;
    
    /** The Constant COPY_INT_UBYTE. */
    public static final int COPY_INT_UBYTE = 252;
    
    /** The Constant COPY_INT_USHORT. */
    public static final int COPY_INT_USHORT = 253;
    
    /** The Constant COPY_INT_INT. */
    public static final int COPY_INT_INT = 254;
    
    /** The Constant COPY_LONG_INT. */
    public static final int COPY_LONG_INT = 255;

    /** The buf. */
    private ByteArrayOutputStream buf = new ByteArrayOutputStream();

    /** The debug. */
    private boolean debug = false;
    
    /** The output. */
    private DataOutputStream output = null;
    
    /**
     * Constructs a new GDiffWriter.
     *
     * @param os the os
     * @throws IOException Signals that an I/O exception has occurred.
     */
    public GDiffWriter(DataOutputStream os) throws IOException {
        this.output = os;
        // write magic string "d1 ff d1 ff 04"
        output.writeByte(0xd1);
        output.writeByte(0xff);
        output.writeByte(0xd1);
        output.writeByte(0xff);
        output.writeByte(0x04);
    }
    
    /**
     * Constructs a new GDiffWriter.
     *
     * @param output the output
     * @throws IOException Signals that an I/O exception has occurred.
     */
    public GDiffWriter(OutputStream output) throws IOException {
        this(new DataOutputStream(output));
    }

    /* (non-Javadoc)
     * @see com.nothome.delta.DiffWriter#addCopy(long, int)
     */
    @Override
	public void addCopy(long offset, int length) throws IOException {
        writeBuf();
        
        //output debug data        
        if (debug)
            System.err.println("COPY off: " + offset + ", len: " + length);
        
        // output real data
        if (offset > Integer.MAX_VALUE) {
            // Actually, we don't support longer files than int.MAX_VALUE at the moment..
            output.writeByte(COPY_LONG_INT);
            output.writeLong(offset);
            output.writeInt(length);
        } else if (offset < 65536)  {
            if (length < 256) {                
                output.writeByte(COPY_USHORT_UBYTE);
                output.writeShort((int)offset);
                output.writeByte(length);
            } else if (length > 65535) {
                output.writeByte(COPY_USHORT_INT);
                output.writeShort((int)offset);
                output.writeInt(length);
            } else {
                output.writeByte(COPY_USHORT_USHORT);
                output.writeShort((int)offset);
                output.writeShort(length);
            }
        } else {
            if (length < 256) {
                output.writeByte(COPY_INT_UBYTE);
                output.writeInt((int)offset);
                output.writeByte(length);
            } else if (length > 65535) {
                output.writeByte(COPY_INT_INT);
                output.writeInt((int)offset);
                output.writeInt(length);
            } else {
                output.writeByte(COPY_INT_USHORT);
                output.writeInt((int)offset);
                output.writeShort(length);
            }
        }
    }
    
    /**
     * Adds a data byte.
     *
     * @param b the b
     * @throws IOException Signals that an I/O exception has occurred.
     */
    @Override
	public void addData(byte b) throws IOException {
        buf.write(b);
        if (buf.size() >= CHUNK_SIZE)
            writeBuf();
    }
    
    /**
     * Write buf.
     *
     * @throws IOException Signals that an I/O exception has occurred.
     */
    private void writeBuf() throws IOException {
        if (buf.size() > 0) {
            if (buf.size() <= DATA_MAX) {
                output.writeByte(buf.size());
            } else if (buf.size() <= 65535) {
                output.writeByte(DATA_USHORT);
                output.writeShort(buf.size());
            } else {
                output.writeByte(DATA_INT);
                output.writeInt(buf.size());
            }
            buf.writeTo(output);
            buf.reset();
        }
    }
    
    /**
     * Flushes accumulated data bytes, if any.
     *
     * @throws IOException Signals that an I/O exception has occurred.
     */
    @Override
	public void flush() throws IOException 
    { 
		writeBuf(); 
    	output.flush(); 
    }
    
    /**
     * Writes the final EOF byte, closes the underlying stream.
     *
     * @throws IOException Signals that an I/O exception has occurred.
     */
    @Override
	public void close() throws IOException {
        try (OutputStream os = output) {
        	this.flush();
        	output.write(EOF);
        }
    }

}