/* 
 *    Binary class
 *
 *  Written by Damir Perovic, Zagreb, Croatia.
 *  Freeware, distributed "As Is". No warranties of any kind.
 *  No part of this program is permitted for copy or use of any kind.
 *  Copyright 2000 by Damir Perovic
 */

class Binary
{
  // array of bits
  boolean[] bits;

/**********************************************
 *                CONSTRUCTORS
 **********************************************/
  // constructor - create array of boolean
  Binary(int size) {
    // create arrays
    bits = new boolean[size];
    // set false as default
    clearAll();
  }

  // constructor - create array of boolean and assing values
  Binary(boolean[] value) {
    // create arrays
    bits = new boolean[value.length];
    // set values
    for (int i=0; i<bits.length; i++) {
      bits[i] = value[i];
    }
  }

  // constructor - create array of boolean and assing another Binary
  Binary(Binary value) {
    // create arrays
    bits = new boolean[value.bits.length];
    // set values
    for (int i=0; i<bits.length; i++) {
      bits[i] = value.bits[i];
    }
  }

/**********************************************
 *        BIT MANIPULATOR METHODS
 **********************************************/
  // set (all true - 1)
  void setAll() {
    for (int i=0; i<bits.length; i++) {
      bits[i] = true;
    }
  }

  // clear (all false - 0)
  void clearAll() {
    for (int i=0; i<bits.length; i++) {
      bits[i] = false;
    }
  }

  // change bit
  void setBit(int index, boolean value) {
    bits[index] = value;
  }

  // change values - set from boolean array
  void set(boolean[] value) {
    for (int i=0; i<bits.length; i++) {
      bits[i] = value[i];
    }
  }

  // change values - set from long
  void set(long value) {
    for (int i=0; i<bits.length; i++) {
      bits[bits.length - i - 1] = ((value >> i) & 1) == 1;
    }
  }

  // change values - set from string
  void set(String value) {
    byte[] b = value.getBytes();

    try {
      for (int i=0; i<bits.length; i++) {
        bits[i] = ((b[i/8] << (i % 8)) & 128) == 128;
      }
    } catch (IndexOutOfBoundsException e) {}
  }

  // change values - set from string
  void setHexString(String value) {
    char[] ch = value.toCharArray();

    // for all chars
    for (int i=0; i<ch.length; i++) {
      int dig = Character.digit(ch[i], 16);
      if (dig < 0) dig = 0;
      // hex to binary
      for (int j=0; j<4; j++) {
        bits[i*4 + j] = ((dig << j) & 8) == 8;
      }
    }
  }

  // change values - set from binary
  void set(Binary value) {
    // set values
    for (int i=0; i<bits.length; i++) {
      bits[i] = value.bits[i];
    }
  }

  // rotate left <--
  void rotateLeft() {
    boolean bit = bits[0];
    for (int i=0; i<bits.length-1; i++) {
      bits[i] = bits[i+1];
    }
    bits[bits.length-1] = bit;
  }

  // rotate right -->
  void rotateRight() {
    boolean bit = bits[bits.length-1];
    for (int i=bits.length-1; i>0; i--) {
      bits[i] = bits[i-1];
    }
    bits[0] = bit;
  }


/**********************************************
 *                GET METHODS
 **********************************************/
  boolean getBit(int index) {
    return bits[index];
  }

  boolean[] getArray() {
    return bits;
  }

  int getLength() {
    return bits.length;
  }


/**********************************************
 *        PUBLIC BIT ARRAY METHODS
 **********************************************/
  static public void and(Binary source1, Binary source2, Binary dest) {
    for (int i=0; i<dest.bits.length; i++) {
      dest.bits[i] = source1.bits[i] & source2.bits[i];
    }
  }

  static public void or(Binary source1, Binary source2, Binary dest) {
    for (int i=0; i<dest.bits.length; i++) {
      dest.bits[i] = source1.bits[i] | source2.bits[i];
    }
  }

  static public void xor(Binary source1, Binary source2, Binary dest) {
    for (int i=0; i<dest.bits.length; i++) {
      dest.bits[i] = source1.bits[i] ^ source2.bits[i];
    }
  }


/**********************************************
 *                TO STRING
 **********************************************/
  public String toString() {
    String s = "";
    for (int i=0; i<bits.length; i++) {
      if (bits[i]) s = s + "1";
              else s = s + "0";
    }
    return s;
  }

  public String toHex() {
    String s = "";
    for (int i=bits.length-1; i>=0; i-=4) {
      int b = 0;
      // every four bits one hex-a digit
      try {
        if (bits[i - 0]) b += 1;
        if (bits[i - 1]) b += 2;
        if (bits[i - 2]) b += 4;
        if (bits[i - 3]) b += 8;
      } catch (IndexOutOfBoundsException e) {}
      s += Character.forDigit(b, 16);
    }
    return new StringBuffer(s).reverse().toString();
  }

  public String toText() {
    String s = "";
    for (int i=bits.length-1; i>=0; i-=8) {
      int b = 0;
      // every eight bits one char
      try {
        if (bits[i - 0]) b += 1;
        if (bits[i - 1]) b += 2;
        if (bits[i - 2]) b += 4;
        if (bits[i - 3]) b += 8;
        if (bits[i - 4]) b += 16;
        if (bits[i - 5]) b += 32;
        if (bits[i - 6]) b += 64;
        if (bits[i - 7]) b += 128;
      } catch (IndexOutOfBoundsException e) {}
      s += (char) b;
    }
    return new StringBuffer(s).reverse().toString();
  }
}