Java example source code file (UUEncoder.java)

This example Java source code file (UUEncoder.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

characterencoder, ioexception, printstream, string, uuencoder

The UUEncoder.java Java example source code

/*
 * Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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 General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package sun.misc;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.IOException;

/**
 * This class implements a Berkeley uu character encoder. This encoder
 * was made famous by uuencode program.
 *
 * The basic character coding is algorithmic, taking 6 bits of binary
 * data and adding it to an ASCII ' ' (space) character. This converts
 * these six bits into a printable representation. Note that it depends
 * on the ASCII character encoding standard for english. Groups of three
 * bytes are converted into 4 characters by treating the three bytes
 * a four 6 bit groups, group 1 is byte 1's most significant six bits,
 * group 2 is byte 1's least significant two bits plus byte 2's four
 * most significant bits. etc.
 *
 * In this encoding, the buffer prefix is:
 * <pre>
 *     begin [mode] [filename]
 * </pre>
 *
 * This is followed by one or more lines of the form:
 * <pre>
 *      (len)(data)(data)(data) ...
 * </pre>
 * where (len) is the number of bytes on this line. Note that groupings
 * are always four characters, even if length is not a multiple of three
 * bytes. When less than three characters are encoded, the values of the
 * last remaining bytes is undefined and should be ignored.
 *
 * The last line of data in a uuencoded file is represented by a single
 * space character. This is translated by the decoding engine to a line
 * length of zero. This is immediately followed by a line which contains
 * the word 'end[newline]'
 *
 * @author      Chuck McManis
 * @see         CharacterEncoder
 * @see         UUDecoder
 */
public class UUEncoder extends CharacterEncoder {

    /**
     * This name is stored in the begin line.
     */
    private String bufferName;

    /**
     * Represents UNIX(tm) mode bits. Generally three octal digits representing
     * read, write, and execute permission of the owner, group owner, and
     * others. They should be interpreted as the bit groups:
     * (owner) (group) (others)
     *  rwx      rwx     rwx    (r = read, w = write, x = execute)
     *
     * By default these are set to 644 (UNIX rw-r--r-- permissions).
     */
    private int mode;


    /**
     * Default - buffer begin line will be:
     * <pre>
     *  begin 644 encoder.buf
     * </pre>
     */
    public UUEncoder() {
        bufferName = "encoder.buf";
        mode = 644;
    }

    /**
     * Specifies a name for the encoded buffer, begin line will be:
     * <pre>
     *  begin 644 [FNAME]
     * </pre>
     */
    public UUEncoder(String fname) {
        bufferName = fname;
        mode = 644;
    }

    /**
     * Specifies a name and mode for the encoded buffer, begin line will be:
     * <pre>
     *  begin [MODE] [FNAME]
     * </pre>
     */
    public UUEncoder(String fname, int newMode) {
        bufferName = fname;
        mode = newMode;
    }

    /** number of bytes per atom in uuencoding is 3 */
    protected int bytesPerAtom() {
        return (3);
    }

    /** number of bytes per line in uuencoding is 45 */
    protected int bytesPerLine() {
        return (45);
    }

    /**
     * encodeAtom - take three bytes and encodes them into 4 characters
     * If len is less than 3 then remaining bytes are filled with '1'.
     * This insures that the last line won't end in spaces and potentiallly
     * be truncated.
     */
    protected void encodeAtom(OutputStream outStream, byte data[], int offset, int len)
        throws IOException {
        byte    a, b = 1, c = 1;
        int     c1, c2, c3, c4;

        a = data[offset];
        if (len > 1) {
            b = data[offset+1];
        }
        if (len > 2) {
            c = data[offset+2];
        }

        c1 = (a >>> 2) & 0x3f;
        c2 = ((a << 4) & 0x30) | ((b >>> 4) & 0xf);
        c3 = ((b << 2) & 0x3c) | ((c >>> 6) & 0x3);
        c4 = c & 0x3f;
        outStream.write(c1 + ' ');
        outStream.write(c2 + ' ');
        outStream.write(c3 + ' ');
        outStream.write(c4 + ' ');
        return;
    }

    /**
     * Encode the line prefix which consists of the single character. The
     * lenght is added to the value of ' ' (32 decimal) and printed.
     */
    protected void encodeLinePrefix(OutputStream outStream, int length)
        throws IOException {
        outStream.write((length & 0x3f) + ' ');
    }


    /**
     * The line suffix for uuencoded files is simply a new line.
     */
    protected void encodeLineSuffix(OutputStream outStream) throws IOException {
        pStream.println();
    }

    /**
     * encodeBufferPrefix writes the begin line to the output stream.
     */
    protected void encodeBufferPrefix(OutputStream a) throws IOException {
        super.pStream = new PrintStream(a);
        super.pStream.print("begin "+mode+" ");
        if (bufferName != null) {
            super.pStream.println(bufferName);
        } else {
            super.pStream.println("encoder.bin");
        }
        super.pStream.flush();
    }

    /**
     * encodeBufferSuffix writes the single line containing space (' ') and
     * the line containing the word 'end' to the output stream.
     */
    protected void encodeBufferSuffix(OutputStream a) throws IOException {
        super.pStream.println(" \nend");
        super.pStream.flush();
    }

}