FileDocCategorySizeDatePackage
BinaryCodec.javaAPI DocAndroid 1.5 API10332Wed May 06 22:41:10 BST 2009org.apache.commons.codec.binary

BinaryCodec

public class BinaryCodec extends Object implements org.apache.commons.codec.BinaryEncoder, org.apache.commons.codec.BinaryDecoder
Translates between byte arrays and strings of "0"s and "1"s. TODO: may want to add more bit vector functions like and/or/xor/nand. TODO: also might be good to generate boolean[] from byte[] et. cetera.
author
Apache Software Foundation
since
1.3
version
$Id $

Fields Summary
private static final char[]
EMPTY_CHAR_ARRAY
Empty char array.
private static final byte[]
EMPTY_BYTE_ARRAY
Empty byte array.
private static final int
BIT_0
Mask for bit 0 of a byte.
private static final int
BIT_1
Mask for bit 1 of a byte.
private static final int
BIT_2
Mask for bit 2 of a byte.
private static final int
BIT_3
Mask for bit 3 of a byte.
private static final int
BIT_4
Mask for bit 4 of a byte.
private static final int
BIT_5
Mask for bit 5 of a byte.
private static final int
BIT_6
Mask for bit 6 of a byte.
private static final int
BIT_7
Mask for bit 7 of a byte.
private static final int[]
BITS
Constructors Summary
Methods Summary
public java.lang.Objectdecode(java.lang.Object ascii)
Decodes a byte array where each byte represents an ascii '0' or '1'.

param
ascii each byte represents an ascii '0' or '1'
return
the raw encoded binary where each bit corresponds to a byte in the byte array argument
throws
DecoderException if argument is not a byte[], char[] or String
see
org.apache.commons.codec.Decoder#decode(java.lang.Object)

        if (ascii == null) {
            return EMPTY_BYTE_ARRAY;
        }
        if (ascii instanceof byte[]) {
            return fromAscii((byte[]) ascii);
        }
        if (ascii instanceof char[]) {
            return fromAscii((char[]) ascii);
        }
        if (ascii instanceof String) {
            return fromAscii(((String) ascii).toCharArray());
        }
        throw new DecoderException("argument not a byte array");
    
public byte[]decode(byte[] ascii)
Decodes a byte array where each byte represents an ascii '0' or '1'.

param
ascii each byte represents an ascii '0' or '1'
return
the raw encoded binary where each bit corresponds to a byte in the byte array argument
see
org.apache.commons.codec.Decoder#decode(Object)

        return fromAscii(ascii);
    
public byte[]encode(byte[] raw)
Converts an array of raw binary data into an array of ascii 0 and 1 characters.

param
raw the raw binary data to convert
return
0 and 1 ascii character bytes one for each bit of the argument
see
org.apache.commons.codec.BinaryEncoder#encode(byte[])


                                                                   
        
        return toAsciiBytes(raw);
    
public java.lang.Objectencode(java.lang.Object raw)
Converts an array of raw binary data into an array of ascii 0 and 1 chars.

param
raw the raw binary data to convert
return
0 and 1 ascii character chars one for each bit of the argument
throws
EncoderException if the argument is not a byte[]
see
org.apache.commons.codec.Encoder#encode(java.lang.Object)

        if (!(raw instanceof byte[])) {
            throw new EncoderException("argument not a byte array");
        }
        return toAsciiChars((byte[]) raw);
    
public static byte[]fromAscii(char[] ascii)
Decodes a byte array where each char represents an ascii '0' or '1'.

param
ascii each char represents an ascii '0' or '1'
return
the raw encoded binary where each bit corresponds to a char in the char array argument

        if (ascii == null || ascii.length == 0) {
            return EMPTY_BYTE_ARRAY;
        }
        // get length/8 times bytes with 3 bit shifts to the right of the length
        byte[] l_raw = new byte[ascii.length >> 3];
        /*
         * We decr index jj by 8 as we go along to not recompute indices using multiplication every time inside the
         * loop.
         */
        for (int ii = 0, jj = ascii.length - 1; ii < l_raw.length; ii++, jj -= 8) {
            for (int bits = 0; bits < BITS.length; ++bits) {
                if (ascii[jj - bits] == '1") {
                    l_raw[ii] |= BITS[bits];
                }
            }
        }
        return l_raw;
    
public static byte[]fromAscii(byte[] ascii)
Decodes a byte array where each byte represents an ascii '0' or '1'.

param
ascii each byte represents an ascii '0' or '1'
return
the raw encoded binary where each bit corresponds to a byte in the byte array argument

        if (ascii == null || ascii.length == 0) {
            return EMPTY_BYTE_ARRAY;
        }
        // get length/8 times bytes with 3 bit shifts to the right of the length
        byte[] l_raw = new byte[ascii.length >> 3];
        /*
         * We decr index jj by 8 as we go along to not recompute indices using multiplication every time inside the
         * loop.
         */
        for (int ii = 0, jj = ascii.length - 1; ii < l_raw.length; ii++, jj -= 8) {
            for (int bits = 0; bits < BITS.length; ++bits) {
                if (ascii[jj - bits] == '1") {
                    l_raw[ii] |= BITS[bits];
                }
            }
        }
        return l_raw;
    
public static byte[]toAsciiBytes(byte[] raw)
Converts an array of raw binary data into an array of ascii 0 and 1 character bytes - each byte is a truncated char.

param
raw the raw binary data to convert
return
an array of 0 and 1 character bytes for each bit of the argument
see
org.apache.commons.codec.BinaryEncoder#encode(byte[])

        if (raw == null || raw.length == 0) {
            return EMPTY_BYTE_ARRAY;
        }
        // get 8 times the bytes with 3 bit shifts to the left of the length
        byte[] l_ascii = new byte[raw.length << 3];
        /*
         * We decr index jj by 8 as we go along to not recompute indices using multiplication every time inside the
         * loop.
         */
        for (int ii = 0, jj = l_ascii.length - 1; ii < raw.length; ii++, jj -= 8) {
            for (int bits = 0; bits < BITS.length; ++bits) {
                if ((raw[ii] & BITS[bits]) == 0) {
                    l_ascii[jj - bits] = '0";
                } else {
                    l_ascii[jj - bits] = '1";
                }
            }
        }
        return l_ascii;
    
public static char[]toAsciiChars(byte[] raw)
Converts an array of raw binary data into an array of ascii 0 and 1 characters.

param
raw the raw binary data to convert
return
an array of 0 and 1 characters for each bit of the argument
see
org.apache.commons.codec.BinaryEncoder#encode(byte[])

        if (raw == null || raw.length == 0) {
            return EMPTY_CHAR_ARRAY;
        }
        // get 8 times the bytes with 3 bit shifts to the left of the length
        char[] l_ascii = new char[raw.length << 3];
        /*
         * We decr index jj by 8 as we go along to not recompute indices using multiplication every time inside the
         * loop.
         */
        for (int ii = 0, jj = l_ascii.length - 1; ii < raw.length; ii++, jj -= 8) {
            for (int bits = 0; bits < BITS.length; ++bits) {
                if ((raw[ii] & BITS[bits]) == 0) {
                    l_ascii[jj - bits] = '0";
                } else {
                    l_ascii[jj - bits] = '1";
                }
            }
        }
        return l_ascii;
    
public static java.lang.StringtoAsciiString(byte[] raw)
Converts an array of raw binary data into a String of ascii 0 and 1 characters.

param
raw the raw binary data to convert
return
a String of 0 and 1 characters representing the binary data
see
org.apache.commons.codec.BinaryEncoder#encode(byte[])

        return new String(toAsciiChars(raw));
    
public byte[]toByteArray(java.lang.String ascii)
Decodes a String where each char of the String represents an ascii '0' or '1'.

param
ascii String of '0' and '1' characters
return
the raw encoded binary where each bit corresponds to a byte in the byte array argument
see
org.apache.commons.codec.Decoder#decode(Object)

        if (ascii == null) {
            return EMPTY_BYTE_ARRAY;
        }
        return fromAscii(ascii.toCharArray());