// -- FILE ------------------------------------------------------------------
   // name       : AsnBitString.java
   // project    : Panter: LI
   // created    : lep - 2007.01.03
   // language   : java
   // environment: JDK 1.5.0
   // copyright  : (c) 2006 by Panter llc, Switzerland
   // license    : this is free software licensed under the GPL. see COPYING
   // --------------------------------------------------------------------------
  package ch.panter.li.bi.asn.value;
  
  import ch.panter.li.bi.asn.model.AsnType;
  import ch.panter.li.bi.asn.model.AsnTypes;
  import ch.panter.li.bi.asn.api.BinaryValue;
  import ch.panter.li.bi.util.HashCodeTool;
  import ch.panter.li.bi.util.FlagTool;
  
  
  public class AsnBitString extends AsnByteArrayValueBase implements BinaryValue
  {
  
    public AsnBitString()
    {
      super( AsnTypes.BIT_STRING );
    } // AsnBitString
  
    public AsnBitString( final byte[] bits )
    {
      this();
      setBits( bits );
    } // AsnBitString
  
    public AsnBitString( final byte[] bits, final int bitCount )
    {
      this();
      setBits( bits, bitCount );
    } // AsnBitString
  
    public AsnBitString( final AsnType type )
    {
      super( checkTypeDerivedFrom( type, AsnTypes.BIT_STRING ) );
    } // AsnBitString
  
    public AsnBitString( final AsnBitString copy )
    {
      super( copy );
    } // AsnBitString
  
    public AsnBitString copyAsnValue()
    {
      return new AsnBitString( this );
    } // copyAsnValue
  
    public final byte[] getContent()
    {
      return getBits();
    } // getContent
  
    public final void setContent( final byte[] content )
    {
      setBits( content );
    } // setContent
  
    public final int getBitCount()
    {
      return bitCount;
    } // getBitCount
  
    public final byte[] getBits()
    {
      return getData();
    } // getBits
  
    public final void setBits( final byte[] bits )
    {
      setBits( bits, bits != null ? bits.length * 8 : 0 );
    } // setBits
  
    public final void setBits( final byte[] bits, final int bitCount )
    {
      if ( bits != null && bits.length * 8 < bitCount ) {
        throw new IllegalArgumentException( "bitCount " + bitCount +
          " exceeds byte array length of " + bits.length + " bytes" );
      }
      setData( bits );
      this.bitCount = bitCount;
    } // setBits
  
    // according to ITU-T X.680 - 21.4 the 'leading' bit is numbered 'zero' with following
    // bits having increasing numbers.
    // according to ITU-T X.690 - 8.6.2.1 the encoding shall commence with the 'leading'
    // bit followed by subsequent bits up to the 'trailing' bit (which has the highest number
    // assigned).
    // -> given that the bit numbers should be the bit positions in an 'int-value', we
    // need to reverse the bit order from that in the byte array.
    public final boolean getBit( final int bitPos )
    {
      if ( bitPos >= bitCount ) {
        throw new IllegalArgumentException( "bitPos must be < " + bitCount + " but is " + bitPos );
     }
     final int octetPos = bitPos / 8;
     final int bitPosWithinOctet = bitPos % 8;
     final byte octet = getData()[ octetPos ];
     final byte mask = (byte)( 0x80 >> bitPosWithinOctet );
     return FlagTool.isSet( octet, mask );
   } // getBit
 
   public void assign( final BinaryValue other )
   {
     if ( other != null ) {
       final byte[] data = other.getContent();
       if ( data != null ) {
         if ( other instanceof AsnBitString ) {
           setBits( data, ((AsnBitString)other).getBitCount() );
         } else {
           setBits( data );
         }
       } else {
         setBits( null );
       }
     } else {
       setBits( null );
     }
   } // assign
 
   protected boolean isEqualTo( final Object compare )
   {
     final AsnBitString comp = (AsnBitString)compare;
     return super.isEqualTo( compare ) &&
       this.bitCount == comp.bitCount;
   } // isEqualTo
 
   protected int computeHashCode( final int baseHash )
   {
     int hash = super.computeHashCode( baseHash );
     hash = HashCodeTool.addHashCode( hash, bitCount );
     return hash;
   } // computeHashCode
 
   public String toString()
   {
     final StringBuffer buf = new StringBuffer( "[" );
     buf.append( bitCount );
     buf.append( "-" );
     final byte[] bits = getData();
     if ( bits != null ) {
       if ( bitCount <= 32 ) {
         /* // the reversed variant
         int printedBits = 0;
         for ( int i = bitCount - 1; i >= 0; i--, printedBits++ ) {
           if ( printedBits > 0 ) {
             buf.append( "'" );
           }
           buf.append( getBit( i ) ? "1" : "0" );
         }
         //*/
         //* // the 'normal' variant which corresponds to the hex variant
         final byte msb = (byte)0x80;
         int printedBits = 0;
         for ( int i = 0; i < bits.length && printedBits < bitCount; i++ ) {
           if ( i > 0 ) {
             buf.append( "'" );
           }
           byte block = bits[ i ];
           for ( int b = 0; b < 8 && printedBits < bitCount; b++ ) {
             buf.append( FlagTool.isSet( block, msb ) ? "1" : "0" );
             block = (byte)( ( ( block & 0xFF ) << 1 ) & 0xFF );
             printedBits++;
           }
         }
         //*/
       } else {
         // TODO: encode bits to human readable hex format
         buf.append( bits );
       }
     }
     buf.append( "]" );
     return buf.toString();
   } // toString
 
   // members
   private int bitCount;
 
 } // class AsnBitString
 
 // -- EOF -------------------------------------------------------------------