bitvector.java

jamod is an object oriented implementation of the Modbus protocol, realized 100 in Java. It allows

//License
/***
 * Java Modbus Library (jamod)
 * Copyright (c) 2002-2004, jamod development team
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * Neither the name of the author nor the names of its contributors
 * may be used to endorse or promote products derived from this software
 * without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 ***/
package net.wimpi.modbus.util;


/**
 * Class that implements a collection for
 * bits, storing them packed into bytes.
 * Per default the access operations will index from
 * the LSB (rightmost) bit.
 *
 * @author Dieter Wimberger
 * @version 1.2rc1 (09/11/2004)
 */
public final class BitVector {

  //instance attributes
  private int m_Size;
  private byte[] m_Data;
  private boolean m_MSBAccess = false;

  /**
   * Constructs a new <tt>BitVector</tt> instance
   * with a given size.
   * <p>
   * @param size the number of bits the <tt>BitVector</tt>
   *        should be able to hold.
   */
  public BitVector(int size) {
    //store bits
    m_Size = size;

    //calculate size in bytes
    if ((size % 8) > 0) {
      size = (size / 8) + 1;
    } else {
      size = (size / 8);
    }
    m_Data = new byte[size];
  }//constructor

  /**
   * Toggles the flag deciding whether the LSB
   * or the MSB of the byte corresponds to the
   * first bit (index=0).
   *
   * @param b true if LSB=0 up to MSB=7, false otherwise.
   */
  public void toggleAccess(boolean b) {
    m_MSBAccess = !m_MSBAccess;
  }//toggleAccess

  /**
   * Tests if this <tt>BitVector</tt> has
   * the LSB (rightmost) as the first bit
   * (i.e. at index 0).
   *
   * @return true if LSB=0 up to MSB=7, false otherwise.
   */
  public boolean isLSBAccess() {
    return !m_MSBAccess;
  }//isLSBAccess

  /**
   * Tests if this <tt>BitVector</tt> has
   * the MSB (leftmost) as the first bit
   * (i.e. at index 0).
   *
   * @return true if LSB=0 up to MSB=7, false otherwise.
   */
  public boolean isMSBAccess() {
    return m_MSBAccess;
  }//isMSBAccess

  /**
   * Returns the <tt>byte[]</tt> which is used to store
   * the bits of this <tt>BitVector</tt>.
   * <p>
   * @return the <tt>byte[]</tt> used to store the bits.
   */
  public final byte[] getBytes() {
    return m_Data;
  }//getBytes

  /**
   * Sets the <tt>byte[]</tt> which stores
   * the bits of this <tt>BitVector</tt>.
   * <p>
   * @param data a <tt>byte[]</tt>.
   */
  public final void setBytes(byte[] data) {
    System.arraycopy(data, 0, m_Data, 0, data.length);
  }//setBytes

  /**
   * Sets the <tt>byte[]</tt> which stores
   * the bits of this <tt>BitVector</tt>.
   * <p>
   * @param data a <tt>byte[]</tt>.
   */
  public final void setBytes(byte[] data, int size) {
    System.arraycopy(data, 0, m_Data, 0, data.length);
    m_Size = size;
  }//setBytes

  /**
   * Returns the state of the bit at the given index of this
   * <tt>BitVector</tt>.
   * <p>
   * @param index the index of the bit to be returned.
   *
   * @return true if the bit at the specified index is set,
   *         false otherwise.
   *
   * @throws IndexOutOfBoundsException if the index is out of bounds.
   */
  public final boolean getBit(int index)
      throws IndexOutOfBoundsException {
    index = translateIndex(index);
    //System.out.println("Get bit #" + index);
    return (
        (m_Data[byteIndex(index)]
        & (0x01 << bitIndex(index))) != 0
        ) ? true : false;
  }//getBit


  /**
   * Sets the state of the bit at the given index of
   * this <tt>BitVector</tt>.
   * <p>
   * @param index the index of the bit to be set.
   * @param b true if the bit should be set, false if it should be reset.
   *
   * @throws IndexOutOfBoundsException if the index is out of bounds.
   */
  public final void setBit(int index, boolean b)
      throws IndexOutOfBoundsException {
    index = translateIndex(index);
    //System.out.println("Set bit #"+index);
    int value = ((b) ? 1 : 0);
    int byteNum = byteIndex(index);
    int bitNum = bitIndex(index);
    m_Data[byteNum] = (byte) (
        (m_Data[byteNum] & ~(0x01 << bitNum))
        | ((value & 0x01) << bitNum)
        );
  }//setBit

  /**
   * Returns the number of bits in this <tt>BitVector</tt>
   * as <tt>int</tt>.
   * <p>
   * @return the number of bits in this <tt>BitVector</tt>.
   */
  public final int size() {
    return m_Size;
  }//size

  /**
   * Forces the number of bits in this <tt>BitVector</tt>.
   * 
   * @param size
   * @throws IllegalArgumentException if the size exceeds
   *         the byte[] store size multiplied by 8.
   */
  public final void forceSize(int size) {
    if(size > m_Data.length * 8) {
      throw new IllegalArgumentException("Size exceeds byte[] store.");
    } else {
      m_Size = size;
    }
  }//forceSize

  /**
   * Returns the number of bytes used to store the
   * collection of bits as <tt>int</tt>.
   * <p>
   * @return the number of bits in this <tt>BitVector</tt>.
   */
  public final int byteSize() {
    return m_Data.length;
  }//byteSize

  /**
   * Returns a <tt>String</tt> representing the
   * contents of the bit collection in a way that
   * can be printed to a screen or log.
   * <p>
   * Note that this representation will <em>ALLWAYS</em>
   * show the MSB to the left and the LSB to the right
   * in each byte.
   *
   * @return a <tt>String</tt> representing this <tt>BitVector</tt>.
   */
  public String toString() {
    StringBuffer sbuf = new StringBuffer();
    for (int i = 0; i < size(); i++) {
      int idx = doTranslateIndex(i);
      sbuf.append(
          ((((m_Data[byteIndex(idx)]
          & (0x01 << bitIndex(idx))) != 0
          ) ? true : false) ? '1' : '0')
      );
      if (((i + 1) % 8) == 0) {
        sbuf.append(" ");
      }
    }
    return sbuf.toString();
  }//toString


  /**
   * Returns the index of the byte in the the byte array
   * that contains the given bit.
   * <p>
   * @param index the index of the bit.
   *
   * @return the index of the byte where the given bit is stored.
   *
   * @throws IndexOutOfBoundsException if index is
   *         out of bounds.
   */
  private final int byteIndex(int index)
      throws IndexOutOfBoundsException {

    if (index < 0 || index >= m_Data.length * 8) {
      throw new IndexOutOfBoundsException();
    } else {
      return index / 8;
    }
  }//byteIndex

  /**
   * Returns the index of the given bit in the byte
   * where it it stored.
   * <p>
   * @param index the index of the bit.
   *
   * @return the bit index relative to the position in the byte
   *         that stores the specified bit.
   *
   * @throws IndexOutOfBoundsException if index is
   *         out of bounds.
   */
  private final int bitIndex(int index)
      throws IndexOutOfBoundsException {

    if (index < 0 || index >= m_Data.length * 8) {
      throw new IndexOutOfBoundsException();
    } else {
      return index % 8;
    }
  }//bitIndex

  private final int translateIndex(int idx) {
    if (m_MSBAccess) {
      int mod4 = idx % 4;
      int div4 = idx / 4;

      if ((div4 % 2) != 0) {
        //odd
        return (idx + ODD_OFFSETS[mod4]);
      } else {
        //straight
        return (idx + STRAIGHT_OFFSETS[mod4]);
      }
    } else {
      return idx;
    }
  }//translateIndex

  private static final int doTranslateIndex(int idx) {

      int mod4 = idx % 4;
      int div4 = idx / 4;

      if ((div4 % 2) != 0) {
        //odd
        return (idx + ODD_OFFSETS[mod4]);
      } else {
        //straight
        return (idx + STRAIGHT_OFFSETS[mod4]);
      }
  }//translateIndex

  /**
   * Factory method for creating a <tt>BitVector</tt> instance
   * wrapping the given byte data.
   *
   * @param data a byte[] containing packed bits.
   * @return the newly created <tt>BitVector</tt> instance.
   */
  public static BitVector createBitVector(byte[] data, int size) {
    BitVector bv = new BitVector(data.length * 8);
    bv.setBytes(data);
    bv.m_Size = size;
    return bv;
  }//createBitVector

  /**
   * Factory method for creating a <tt>BitVector</tt> instance
   * wrapping the given byte data.
   *
   * @param data a byte[] containing packed bits.
   * @return the newly created <tt>BitVector</tt> instance.
   */
  public static BitVector createBitVector(byte[] data) {
    BitVector bv = new BitVector(data.length * 8);
    bv.setBytes(data);
    return bv;
  }//createBitVector

  public static void main(String[] args) {
    BitVector test = new BitVector(24);
    System.out.println(test.isLSBAccess());
    test.setBit(7, true);
    System.out.println(test.getBit(7));
    test.toggleAccess(true);
    System.out.println(test.getBit(7));

    test.toggleAccess(true);
    test.setBit(6, true);
    test.setBit(3, true);
    test.setBit(2, true);

    test.setBit(0, true);
    test.setBit(8,true);
    test.setBit(10,true);

    System.out.println(test);
    test.toggleAccess(true);
    System.out.println(test);
    test.toggleAccess(true);
    System.out.println(test);

    System.out.println(ModbusUtil.toHex(test.getBytes()));
  }


  private static final int[] ODD_OFFSETS = {-1, -3, -5, -7};
  private static final int[] STRAIGHT_OFFSETS = {7, 5, 3, 1};
}//class BitVector