Converting A Byte Array Into A Bit Stream Using ColdFusion And BigInteger

<cfscript>
// NOTE: CFScript tags used for Gist color-coding. They can be removed.
component
	output = false
	hint = "I provide a bit-based stream wrapper to an underlying byte array."
	{

	/**
	* I take either a binary value (byte array) or a string and provide read-access to
	* the underlying bits. If a string is passed-in, it is assumed to be UTF-8 encoded.
	*
	* @output false
	*/
	public any function init( required any input ) {

		// If the input is a byte array, we can use it as-is.
		if ( isBinary( input ) ) {

			var byteArray = input;

		// If the input is a string, we can decode the bytes.
		} else if ( isSimpleValue( input ) ) {

			var byteArray = charsetDecode( input, "utf-8" );

		// If input is not supported for conversion.
		} else {

			throw(
				type = "InvalidInput",
				message = "Input must be one of the following: ByteArray, String, Integer"
			);

		}

		// We're going to use the BigInteger to access the individual bits.
		source = createObject( "java", "java.math.BigInteger" ).init( byteArray );

		// If the leading bit(s) are zeros, they are not included in the bit length of
		// the BitInteger, which will mess up our read. But, since this is all coming
		// from a byte array, we can determine the bit length using the number of bytes.
		bitLength = ( arrayLen( byteArray ) * 8 );

		// Since the bits in the BigInteger are zero-based, we need to start at n-1.
		bitIndex = ( bitLength - 1 );

		// Each read action will start with this result and then start shifting and
		// settings bits (which will return a new BigInteger instance).
		resultTemplate = createObject( "java", "java.math.BigInteger" )
			.init( javaCast( "string", "0" ) )
		;

		// When there are no more bits to read in the underlying source, we are going
		// to return (-1) to indicate the end of the stream.
		nonResultTemplate = createObject( "java", "java.math.BigInteger" )
			.init( javaCast( "string", "-1" ) )
		;

	}


	/**
	* I read the given number of bits from the stream and return them as the right-most
	* bits of an integer. If there are not enough bits available for a full-read, the
	* result will be right-padded with zeros. When there are no more bits to read, a -1
	* is returned.
	*
	* @output false
	*/
	public numeric function read( required numeric size ) {

		return( readBigInteger( size ).intValue() );

	}


	/**
	* I read the given number of bits from the stream and return them as the right-most
	* bits of a BigInteger. If there are not enough bits available for a full-read, the
	* result will be right-padded with zeros. When there are no more bits to read, a -1
	* is returned (in the form of a BigInteger).
	*
	* @output false
	*/
	public any function readBigInteger( required numeric size ) {

		// If we've gone past the bounds of BigInteger, return -1. There are no more
		// bits to read from the underlying source.
		if ( bitIndex < 0 ) {

			return( nonResultTemplate );

		}

		// Start out result as zero.
		var result = resultTemplate;

		// When read read from the stream, we'll have to see if we miss any bits, which
		// will have to be right-padded with zeros.
		var missingBits = size;

		// Keep reading a bit at a time until we fulfill the size requirement or, until
		// we run out of bits to read.
		while ( missingBits && ( bitIndex >= 0 ) ) {

			// Will add a zero as the right-most bit.
			result = result.shiftLeft( javaCast( "int", 1 ) );

			// If the source bit is set (ie, non-zero), then toggle the right-most result
			// bit (the one we just left-shifted into the result).
			if ( source.testBit( javaCast( "int", bitIndex ) ) ) {

				result = result.setBit( javaCast( "int", 0 ) );

			}

			// Update our while-conditions.
			missingBits--;
			bitIndex--;

		}

		// If we ran out of bits, mid-read, then we have to right-pad with zeros.
		while ( missingBits-- ) {

			result = result.shiftLeft( javaCast( "int", 1 ) );

		}

		return( result );

	}

}
</cfscript>

<cfscript>

	// Each of the characters in this string is represented by a byte, which is composed
	// of 8 bits. We're going to wrap this in a BitStream and then read chunks of the
	// bits out, 5 at a time.
	input = "abc";

	// Create the bit stream.
	stream = new BitStream( input );


	// To demonstrate that the bit stream works, let's output the bits of the input
	// string. This way, we can see how our 5-bit reads line up with the bits of the
	// entire stream.
	for ( character in listToArray( input, "" ) ) {

		bitValue = formatBaseN( asc( character ), 2 );

		// NOTE: We are using numberFormat so we don't lose leading zeros.
		writeOutput( numberFormat( bitValue, "00000000" ) );

	}

	writeOutput( "<br />" );


	results = [];

	// Read first 5 bits.
	result = stream.read( 5 );

	// When we run out of bits, the stream will return -1.
	while ( result != -1 ) {

		// Get the underlying bit-string in our read chunk.
		bitValue = formatBaseN( result, 2 );

		// NOTE: We are using numberFormat so we don't lose leading zeros.
		arrayAppend( results, numberFormat( bitValue, "00000" ) );

		// Read the next chunk of bits.
		result = stream.read( 5 );

	}

	// Now that we've read all the chunks of 5 bits, output with and without a space-
	// delimiter. This will help us see if the resultant bits line up with the input
	// stream AND also help us see where the chunks were bounded.
	writeOutput( arrayToList( results, "" ) );
	writeOutput( "<br />" );
	writeOutput( arrayToList( results, " " ) );

</cfscript>