bitarrayoutputstream.java

jwap 协议 udp 可以用于手机通讯

/**
 * 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.io.ByteArrayOutputStream;
import java.util.BitSet;


public class BitArrayOutputStream {
    public 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
    ByteArrayOutputStream outstream = new ByteArrayOutputStream();
    int aktBit = 0;
    int sByte=0;

    ////////////////////////////////////////////////////////////////////////////
    //////////////////// METHODS CONCERNING THE STREAM /////////////////////////

    /**
     * fills up the aktual byte with bits "0" for fill = false
     *                                and "1" for fill = true
     */
    public synchronized void flush(boolean fill) {
        while (aktBit != 0) {
            write(fill);
        }
    }

    public byte[] toByteArray() {
        return outstream.toByteArray();
    }

    ////////////////////////////////////////////////////////////////////////////
    //////////////////// WRITE SINGLE BITS /////////////////////////////////////

    /**
     * writes a bit down to the stream.
     * is used by all the other methods in this class.
     */
    public synchronized void write(boolean b) {
        if(b) {
            sByte |= (1 << (7-aktBit));
        }
        aktBit++;

        // if byte is full, write down into outstream
        if (aktBit == 8) {
            outstream.write(sByte);
            aktBit = sByte = 0;
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    //////////////////// WRITE METHODS /////////////////////////////////////////

    /**
     * writes <code>count</code> bits from byte <code>_b</code> beginning on the right hand.
     * <code>Count</code> has NOT to be in byte-size (e.g. 8, 16, 24, 32,...)
     */
    
    public synchronized void write(byte _b, int count) {
        int b = _b;

        // bit #0 (encoding positive/negative numbers)
        if (b < 0) {
            if (count == 8) {
                write(true);
                count = 7;
            }

            b += 128;

            // if _b >= 0
        } else {
            if (count == 8) {
                write(false);
                count = 7;
            }
        }

        for (int i = 7; i >= count; i--) {
            if (b >= pot[i]) {
                b -= pot[i];
            }
        }

        // bits #1 - #7
        for (int i = count - 1; i >= 0; i--) {
            if (b >= pot[i]) {
                b -= pot[i];
                write(true);
            } else {
                write(false);
            }
        }
    }
    
    // Optimized write, doesn't work yet...
    private synchronized void _write(byte _b, int count) {
        int b = _b&0xFF, m = 0x80;
        for( int i=0; i<count; i++ ) {
            write( (b & (m>>i)) != 0 );
        }
    }

    public synchronized void reset() {
        outstream.reset();
        sByte = aktBit = 0;
    }

    public synchronized void write(int b, int count) {
        // bit #0 (encoding positive/negative numbers)
        if (b < 0) {
            if (count == 16) {
                write(true);
                count = 15;
            }

            b += 32768;

            // if b >= 0
        } else {
            if (count == 16) {
                write(false);
                count = 15;
            }
        }

        for (int i = 15; i >= count; i--) {
            if (b >= pot[i]) {
                b -= pot[i];
            }
        }

        // bits #1 - #7
        for (int i = count - 1; i >= 0; i--) {
            if (b >= pot[i]) {
                b -= pot[i];
                write(true);
            } else {
                write(false);
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    //////////////////// WRITE UINT* METHODS ///////////////////////////////////

    /**
     * writes <code>count</code> bits of an integer into the stream beginning on the right hand.
     * <code>Count</code> has NOT to be in byte-size (e.g. 8, 16, 24, 32,...)
     *
     * also use it for a uint8  (use bits=8)
     *                or unit16 (use bits=16)
     *                or uint32 (use bits=32)
     * according to WAP-230-WSP-10010705-a secition 8.1.2
     */
    public synchronized void write(long b, int count) {
        // bit #0 (encoding positive/negative numbers)
        if (b < 0) {
            if (count == 32) {
                write(true);
                count = 31;
            }

            b += 2147483648L;

            // if b >= 0
        } else {
            if (count == 32) {
                write(false);
                count = 31;
            }
        }

        for (int i = 31; i >= count; i--) {
            if (b >= pot[i]) {
                b -= pot[i];
            }
        }

        // bits #1 - #7
        for (int i = count - 1; i >= 0; i--) {
            if (b >= pot[i]) {
                b -= pot[i];
                write(true);
            } else {
                write(false);
            }
        }
    }

    /**
     * write a unintvar
     * according to WAP-230-WSP-10010705-a secition 8.1.2
     */
    public synchronized void writeUintVar(long b) throws NumberFormatException {
        if (b < 0) {
            throw new NumberFormatException("No negative values supported");
        } else if (b == 0) {
            for (int i = 0; i < 8; i++) {
                write(false);
            }
        } else {
            int i = 63;

            while (b < pot[i]) {
                i--;
            }

            int length = i;

            // i+1 ist jetzt die Anzahl der ben鰐igten bits
            int fill = 7 - ((i + 1) % 7); //nur 7 bits payload

            if (fill == 7) {
                fill = 0;
            }

            if (debug) {
                System.out.println("used bits: " + (i + 1) + " | to fill: " +
                    fill);
            }

            // set the continue bit
            if ((i + 1) <= 7) {
                write(false);
            } else {
                write(true);
            }

            // fill up with "0"
            for (int s = 0; s < fill; s++) {
                write(false);
            }

            for (; i >= 0; i--) {
                //write continue bit
                if ((((i + 1) % 7) == 0) && (length > 7)) {
                    if ((i + 1) <= 7) {
                        write(false);
                    } else {
                        write(true);
                    }
                }

                //write payload
                if (b >= pot[i]) {
                    b -= pot[i];
                    write(true);
                } else {
                    write(false);
                }
            }
        }
    }

    /**
     * writes <code>count</code> bits from byte <code>_b</code> beginning on the right hand.
     * <code>Count</code> has NOT to be in byte-size (e.g. 8, 16, 24, 32,...)
     */
    public synchronized void write(byte[] b) {
        for (int i = 0; i < b.length; i++) {
            this.write(b[i], 8);
        }
    }

    /**
     * writing multiple octets according to
     * WAP-230-WSP-20010705-a section 8.4.2.1 "Basic rules for header syntax"
     */

    /*public synchronized void writeMultOct(long b) throws NumberFormatException{
      if (b<0){
        throw new NumberFormatException("No negative values supported");
      } else if (b>127){
        // LONG INTEGER ////////////////////////////////////////////////
        boolean length = false;
        for(int i=63; i>=0; i--){
          if (b >= pot[i]){
            if (length == false) {
              // writing length as short integer
              length = true;
              long thelength=(long)(Math.ceil(((double)i+1)/8));
              writeMultOct(thelength);

              // fill first bits in first byte with "0"
              int swap = 8-((i+1)%8);
              System.out.println("i:" + i + " swap:" + swap + " length:" + thelength);
              if (swap != 8){
                for (int a=0; a<swap; a++){
                  write(false);
                }
              }
            }
            b -= pot[i];
            write(true);
          }
          else if(length == true){
            write(false);
          }
        }
      } else {
        // SHORT INTEGER ////////////////////////////////////////////////
        write(true);
        // bits #1 - #7
        for(int i=6; i>=0; i--){
          if (b >= pot[i]){
            b -= pot[i];
            write(true);
          } else {
            write(false);
          }
        }
      }
    }
    */

    ////////////////////////////////////////////////////////////////////////////
    //////////////////// HELPER METHODS ////////////////////////////////////////

    /**
     * constructs a string representation of the outputstream.
     */
    public synchronized String toString() {
        String result = "";
        byte[] array = outstream.toByteArray();

        for (int i = 0; i < array.length; i++) {
            result += (getBitString(array[i]) + "\r\n");
        }

        result+=getBitString((byte) (sByte&0xFF));

        return result;
    }

    /**
     *  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 += (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) {
        BitArrayOutputStream m = new BitArrayOutputStream();

        //m.write(23L, 8);
        //m.write(18736L, 16);
        m.write("Hallo".getBytes());

        /*try{
          m.writeUintVar(19L);
        } catch (NumberFormatException e){
          e.printStackTrace();
        }*/
        System.out.println(m.toString());
    }
}