Splitting And Joining A Binary File In ColdFusion

<!--- Read in the original binary file. --->
<cffile
	action="readbinary"
	file="#ExpandPath( './sexy.jpg' )#"
	variable="binFile"
	/>


<!--- Get the length of the original binary file. --->
<cfset intLength = ArrayLen( binFile ) />

<!---
	Get the mid point of the byte array. We are goint
	to use this as the split point for our two future
	binary files.
--->
<cfset intMid = Ceiling( intLength / 2 ) />


<!---
	Now, we are going to use the Java ByteBuffer to do the
	heavy lifting for us. We can't use ColdFusion arrays
	directly for manipulation since they are not really
	arrays, but rather Collections (and there's probably
	other complications). The Java ByteBuffer will take
	care of splitting and then later joining our files.

	Create an instance of the static ByteBuffer class so
	that we can refer to it multiple times.
--->
<cfset objByteBuffer = CreateObject(
	"java",
	"java.nio.ByteBuffer"
	) />


<!---
	Using the ByteBuffer class, create two byte buffer
	instances for our two file parts. Because we are
	splitting the original file, we only need to allocate
	space equal to half of the original file (since we
	used Ceiling() in our split).
--->
<cfset objBufferA = objByteBuffer.Allocate(
	JavaCast( "int", intMid )
	) />

<cfset objBufferB = objByteBuffer.Allocate(
	JavaCast( "int", intMid )
	) />


<!---
	Now that we have our two ByteBuffer instance, we are
	going to store half of the original binary byte array
	into each.
--->

<!--- Store first half. --->
<cfset objBufferA.Put(
	binFile,
	JavaCast( "int", 0 ),
	JavaCast( "int", intMid )
	) />

<!--- Store second half. --->
<cfset objBufferB.Put(
	binFile,
	JavaCast( "int", intMid ),
	JavaCast( "int", (intLength - intMid) )
	) />


<!---
	Now, all we have to do is write the two byte arrays to
	disk. In order to get the byte arrays from the ByteBuffer,
	we just need to call its underlying Array() method.
--->

<!--- Write first half. --->
<cffile
	action="write"
	file="#ExpandPath( './sexy_a.jpg' )#"
	output="#objBufferA.Array()#"
	/>

<!--- Write second half. --->
<cffile
	action="write"
	file="#ExpandPath( './sexy_b.jpg' )#"
	output="#objBufferB.Array()#"
	/>



<!---
	ASSERT: At this point, we have taken our original binary
	file and split it up into two parts that have been written
	back to disk. Now, we can go about testing this by reading
	them in again, joinging the individual byte arrays, and
	then streaming to the client.
--->


<!--- Read in the first part. --->
<cffile
	action="readbinary"
	file="#ExpandPath( './sexy_a.jpg' )#"
	variable="binFileA"
	/>

<!--- Read in the second part. --->
<cffile
	action="readbinary"
	file="#ExpandPath( './sexy_b.jpg' )#"
	variable="binFileB"
	/>



<!---
	Again, we are going to create a Java ByteBuffer to do the
	heavy lifting for us. This time, we need to allocate space
	for the resultant byte array which will be equal to the
	length of both binary files.
--->
<cfset arrBinFull = objByteBuffer.Allocate(
	JavaCast(
		"int",
		(ArrayLen( binFileA ) + ArrayLen( binFileB ) )
		)
	) />


<!---
	Add the entire first file's byte array to the byte buffer
	using a zero offset and full length.
--->
<cfset arrBinFull.Put(
	binFileA,
	JavaCast( "int", 0 ),
	JavaCast( "int", ArrayLen( binFileA ) )
	) />

<!---
	Add the entire second file's byte array to the byte buffer
	using a zero offset and full length.
--->
<cfset arrBinFull.Put(
	binFileB,
	JavaCast( "int", 0 ),
	JavaCast( "int", ArrayLen( binFileA ) )
	) />


<!---
	At this point, our Java ByteBuffer should now contain
	the entire byte array the we had in our original file.
	To prove this, we are going to get the underlying byte
	array and stream it to the client.
--->
<cfcontent
	type="image/jpeg"
	variable="#arrBinFull.Array()#"
	/>