bitarrayinputstream.java

WAP协议栈的JAVA实现

/**
 * JWAP - A Java Implementation of the WAP Protocols
 * Copyright (C) 2001-2004 Niko Bender
 *
 * This library 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.1 of the License, or (at your option) any later version.
 *
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package net.sourceforge.jwap.util;

import java.util.*;


/**
 *
 */
public class BitArrayInputStream {
    private static final boolean debug = false;

    // to avoid Math.pow(2,b) take pot[b]
    private static final long[] pot = {
        1L, 2L, 4L, 8L, 16L, 32L, 64L, 128L, 256L, 512L, 1024L, 2048L, 4096L,
        8192L, 16384L, 32768L, 65536L, 131072L, 262144L, 524288L, 1048576L,
        2097152L, 4194304L, 8388608L, 16777216L, 33554432L, 67108864L,
        134217728L, 268435456L, 536870912L, 1073741824L, 2147483648L,
        4294967296L, 8589934592L, 17179869184L, 34359738368L, 68719476736L,
        137438953472L, 274877906944L, 549755813888L, 1099511627776L,
        2199023255552L, 4398046511104L, 8796093022208L, 17592186044416L,
        35184372088832L, 70368744177664L, 140737488355328L, 281474976710656L,
        562949953421312L, 1125899906842624L, 2251799813685248L,
        4503599627370496L, 9007199254740992L, 18014398509481984L,
        36028797018963968L, 72057594037927936L, 144115188075855872L,
        288230376151711744L, 576460752303423488L, 1152921504606846976L,
        2305843009213693952L, 4611686018427387904L, 9223372036854775807L
    }; // b = 64

    public BitArrayInputStream() {
    }

    /**
     * returns if the given bit ist set in byte <code>b</code>
     * 0 is the very left and 7 the very right bit in the byte
     */
    public boolean getBoolean(byte b, int bit) {
        BitSet bitset = getBitSet(b);

        return bitset.get(bit);
    }

    /**
     * returns a byte value of <code>length</code> bits
     * in byte <code>b</code>
     * beginning with bit <code>offset</code>
     * where 0 is the very left and 7 the very right bit in the byte
     */
    public byte getByte(byte b, int offset, int length) {
        BitSet bitset = getBitSet(b);
        byte result = 0;

        for (int i = 0; i < length; i++) {
            int bit = offset + (length - i - 1);

            if (bitset.get(bit)) {
                if (i == 8) {
                    result -= 128;
                } else {
                    result += pot[i];
                }
            }
        }

        return result;
    }

    /**
     * returns a short value of <code>length</code> bits
     * in byte <code>b</code>
     * beginning with bit <code>offset</code>
     * where 0 is the very left and 7 the very right bit in the byte
     */
    public short getShort(byte b1, byte b2, int offset, int length) {
        if (debug) {
            System.out.println("b1: " + BitArrayInputStream.getBitString(b1));
            System.out.println("b2: " + BitArrayInputStream.getBitString(b2));
        }

        BitSet bitset1 = getBitSet(b1);
        BitSet bitset2 = getBitSet(b2);
        short result = 0;
        int bit = length - 1;

        if ((offset < 0) || (length < 0)) {
            throw new IllegalArgumentException(
                "offset < 0 or length < 0 not allowed");
        }

        if ((offset + length) > 16) {
            throw new IllegalArgumentException("Length+length > 16 not allowed");
        }

        // wenn erstes Bit gesetzt und es werden 16 bits betrachtet
        if ((length == 16) && (offset == 0) && bitset1.get(0)) {
            result -= 32768;
            length--;
            offset++;
            bit--;
        }

        // erstes Byte
        int offset1 = offset;
        int length1 = length;

        if ((length + offset) >= 7) {
            length1 = 8 - offset;
        }

        if (debug) {
            System.out.println("offset1: " + offset1);
            System.out.println("length1: " + length1);
        }

        if ((length1 > 0) && (offset1 < 8) && (offset1 >= 0)) {
            for (int i = 0; i < length1; i++) {
                if (debug) {
                    System.out.println("offset1 +i: " + (offset1 + i) +
                        " |bit: " + bit);
                }

                if (bitset1.get(offset1 + i)) {
                    result += pot[bit];
                }

                bit--;
            }
        }

        // zweites Byte
        int length2 = (length + offset) - 8;
        int offset2 = offset - 8;

        if (offset2 < 0) {
            offset2 = 0;
        }

        if (debug) {
            System.out.println("offset2: " + offset2);
            System.out.println("length2: " + length2);
        }

        if ((length2 > 0) && (offset2 < 8) && (offset2 >= 0)) {
            for (int i = 0; i < length2; i++) {
                if (debug) {
                    System.out.println("offset2 +i: " + (offset2 + i) +
                        " |bit: " + bit);
                }

                if (bitset2.get(offset2 + i)) {
                    result += pot[bit];
                }

                bit--;
            }
        }

        return result;
    }

    public int getInt(byte b1, byte b2, byte b3, byte b4, int offset, int length) {
        if (debug) {
            System.out.println("b1: " + BitArrayInputStream.getBitString(b1));
            System.out.println("b2: " + BitArrayInputStream.getBitString(b2));
            System.out.println("b3: " + BitArrayInputStream.getBitString(b3));
            System.out.println("b4: " + BitArrayInputStream.getBitString(b4));
        }

        byte[] bytes = { b1, b2, b3, b4 };
        BitSet bitset = getBitSet(bytes[0]);
        int result = 0;
        int bit = length - 1;

        if ((offset < 0) || (length < 0)) {
            throw new IllegalArgumentException(
                "offset < 0 or length < 0 not allowed");
        }

        if ((offset + length) > 32) {
            throw new IllegalArgumentException("Length+length > 32 not allowed");
        }

        // wenn erstes Bit gesetzt und es werden 32 bits betrachtet
        if ((length == 32) && (offset == 0) && bitset.get(0)) {
            result = -2147483648;
            length--;
            offset++;
            bit--;
        }

        int offsetlocal = offset;
        int lengthlocal = length;

        // erstes Byte
        if ((length + offset) >= 7) {
            lengthlocal = 8 - offset;
        }

        if (debug) {
            System.out.println("offsetlocal: " + offsetlocal);
            System.out.println("lengthlocal: " + lengthlocal);
        }

        if ((lengthlocal > 0) && (offsetlocal < 8) && (offsetlocal >= 0)) {
            for (int i = 0; i < lengthlocal; i++) {
                if (debug) {
                    System.out.println("offsetlocal +i: " + (offset + i) +
                        " |bit: " + bit);
                }

                if (bitset.get(offsetlocal + i)) {
                    result += pot[bit];
                }

                bit--;
            }
        }

        // zweites bis viertes Byte
        for (int m = 1; m < 4; m++) {
            bitset = getBitSet(bytes[m]);
            lengthlocal = (length + offset) - (8 * m);
            offsetlocal = offset - (8 * m);

            if (offsetlocal < 0) {
                offsetlocal = 0;
            }

            if (lengthlocal > 8) {
                lengthlocal = 8;
            }

            if (debug) {
                System.out.println("offsetlocal: " + offsetlocal);
                System.out.println("lengthlocal: " + lengthlocal);
            }

            if ((lengthlocal > 0) && (offsetlocal < 8) && (offsetlocal >= 0)) {
                for (int i = 0; i < lengthlocal; i++) {
                    if (debug) {
                        System.out.println("offsetlocal +i: " +
                            (offsetlocal + i) + " |bit: " + bit);
                    }

                    if (bitset.get(offsetlocal + i)) {
                        result += pot[bit];
                    }

                    bit--;
                }
            }
        }

        return result;
    }

    public long getUIntVar(byte[] bytes, int offset) {
        int lastone = (offset + getLengthOfUIntVar(bytes, offset)) - 1;

        if (debug) {
            System.out.println("Last one: " + lastone);
        }

        int exp = 0; // pot[exp]
        long result = 0;

        for (int aktbyte = lastone; aktbyte >= offset; aktbyte--) {
            // aktbyte ist aktuelles byte
            if (debug) {
                System.out.println("byte: " + aktbyte);
            }

            BitSet set = getBitSet(bytes[aktbyte]);

            for (int i = 7; i > 0; i--) {
                if (debug) {
                    System.out.println("Bit: " + i);
                }

                if (set.get(i)) {
                    result += pot[exp];
                }

                exp++;
            }
        }

        return result;
    }

    public short getUInt8(byte b, int offset, int length) {
        return getShort((byte) 0, b, 8 + offset, length);
    }

    public short getUInt8(byte b) {
        return getUInt8(b, 0, 8);
    }

    public int getUInt16(byte b1, byte b2, int offset, int length) {
        return getInt((byte) 0, (byte) 0, b1, b2, 16, length);
    }

    public int getUInt16(byte b1, byte b2) {
        return getUInt16(b1, b2, 16, 16);
    }

    ////////////////////////////HELPERS//////////////////////////
    public int getLengthOfUIntVar(byte[] bytes, int offset) {
        for (int i = offset; i < bytes.length; i++) {
            if (!(getBitSet(bytes[i]).get(0))) {
                return i - offset + 1;
            }
        }

        return 0;
    }

    /**
     *  Constructs a binary representation of the byte <code>m</code>
     */
    public static String getBitString(byte m) {
        String result = "";

        if (m < 0) {
            result += "1";
            m += 128;

            // if m >= 0
        } else {
            result += "0";
        }

        for (int i = 6; i >= 0; i--) {
            if (m >= pot[i]) {
                m -= pot[i];
                result += "1";
            } else {
                result += "0";
            }
        }

        return result;
    }

    /**
     *  Constructs a binary representation of the byte-array <code>m</code>
     */
    public static String getBitString(byte[] m) {
        String result = "";

        for (int i = 0; i < m.length; i++) {
            result += ("" + i + ": " + getBitString(m[i]) +
            System.getProperty("line.separator"));
        }

        return result;
    }

    /**
     *  Constructs a BitSet of the byte <code>m</code>
     */
    public static BitSet getBitSet(byte m) {
        BitSet result = new BitSet(8);

        if (m < 0) {
            result.set(0);
            m += 128;
        }

        for (int i = 6; i >= 0; i--) {
            if (m >= pot[i]) {
                m -= pot[i];
                result.set(7 - i);
            }
        }

        return result;
    }

    /**
     * Test method
     */
    public static void main(String[] args) {
        BitArrayInputStream b = new BitArrayInputStream();
        BitArrayOutputStream o = new BitArrayOutputStream();
        o.write(3, 8);
        o.write(33123435, 32);
        System.out.println(o.toString());

        byte[] bytes = o.toByteArray();
        System.out.println("" +
            b.getInt(bytes[1], bytes[2], bytes[3], bytes[4], 0, 32));
    }
}