#include <cdevMessageBinary.h>

const unsigned BIT01 = 1;
const unsigned BIT02 = 2;
const unsigned BIT03 = 4;
const unsigned BIT04 = 8;
const unsigned BIT05 = 16;
const unsigned BIT06 = 32;
const unsigned BIT07 = 64;
const unsigned BIT08 = 128;
const unsigned BIT09 = 256;
const unsigned BIT10 = 512;
const unsigned BIT11 = 1024;
const unsigned BIT12 = 2048;
const unsigned BIT13 = 4096;
const unsigned BIT14 = 8192;
const unsigned BIT15 = 16384;
const unsigned BIT16 = 32768;

// *****************************************************************************
// * cdevMessageBinary::map2int ( void )
// *	This method will convert the cdevMessageBinaryMap to a long integer.
// *****************************************************************************
unsigned cdevMessageBinary::map2int ( cdevMessageBinaryMap mapdata, unsigned & value)
	{
	value = (mapdata.value.version << 16);
	if(mapdata.value.clientIDSet!=0)         value |= BIT16;
	if(mapdata.value.transIndexSet!=0)       value |= BIT15;
	if(mapdata.value.cancelTransIndexSet!=0) value |= BIT14;
	if(mapdata.value.localDataIndexSet!=0)   value |= BIT13;
	if(mapdata.value.foreignDataIndexSet!=0) value |= BIT12;
	if(mapdata.value.operationCodeSet!=0)    value |= BIT11;
	if(mapdata.value.completionCodeSet!=0)   value |= BIT10;
	if(mapdata.value.deviceListSet!=0)       value |= BIT09;
	if(mapdata.value.messageSet!=0)          value |= BIT08;
	if(mapdata.value.dataSet!=0)             value |= BIT07;
	if(mapdata.value.contextSet!=0)          value |= BIT06;
	if(mapdata.value.tagMapSet!=0)           value |= BIT05;
	return value;
	}

// *****************************************************************************
// * cdevMessageBinary::int2map ( void )
// *	This method will convert a long  integer to a cdevMessageBinaryMap.
// *****************************************************************************
cdevMessageBinaryMap cdevMessageBinary::int2map ( cdevMessageBinaryMap &mapdata, unsigned value)
	{
	mapdata.rawData                   = 0;
	mapdata.value.version             = (value >> 16);
	mapdata.value.clientIDSet         = (value & BIT16)?1:0;
	mapdata.value.transIndexSet       = (value & BIT15)?1:0;
	mapdata.value.cancelTransIndexSet = (value & BIT14)?1:0;
	mapdata.value.localDataIndexSet   = (value & BIT13)?1:0;
	mapdata.value.foreignDataIndexSet = (value & BIT12)?1:0;
	mapdata.value.operationCodeSet    = (value & BIT11)?1:0;
	mapdata.value.completionCodeSet   = (value & BIT10)?1:0;
	mapdata.value.deviceListSet       = (value & BIT09)?1:0;
	mapdata.value.messageSet          = (value & BIT08)?1:0;
	mapdata.value.dataSet             = (value & BIT07)?1:0;
	mapdata.value.contextSet          = (value & BIT06)?1:0;
	mapdata.value.tagMapSet           = (value & BIT05)?1:0;
	return mapdata;	
	}

// *****************************************************************************
// * cdevMessageBinary::cdevMessageBinary :
// *	Copy constructaor for the class.  Sets all of the variables to the
// *	values stored in the referenced objects.
// *****************************************************************************
cdevMessageBinary::cdevMessageBinary ( cdevMessageBinary & packet )
	: cdevPacketBinary()
	{
	streamIn(packet.binary, packet.binaryLen);
	}

		
// *****************************************************************************
// * cdevMessageBinary::cdevMessageBinary :
// *	This is the default and parameterized constructor. Allows the caller to 
// *    directly specify each of the components.
// *****************************************************************************
cdevMessageBinary::cdevMessageBinary ( short            clientID, 
				       unsigned         transIndex, 
				       unsigned         cancelTransIndex,
				       unsigned         localDataIndex, 
				       unsigned         foreignDataIndex,
				       unsigned         operationCode,
				       int              completionCode,
				       unsigned         deviceCount,
				       char **          deviceList,
				       char *           message,
				       cdevData *       data,
				       cdevData *       context,
				       cdevData *       tagMap)
	: cdevPacketBinary()
	{
	set(clientID, transIndex, cancelTransIndex, localDataIndex, 
	    foreignDataIndex, operationCode, completionCode, deviceCount, 
	    deviceList, message, data, context, tagMap);
	}


// *****************************************************************************
// * cdevMessageBinary::~cdevMessageBinary :
// *	This is the destructor for the class.  
// *****************************************************************************
cdevMessageBinary::~cdevMessageBinary ( void )
	{
	// *********************************************************************
	// * Execute a detach on the embedded data to ensure that it is not
	// * deleted locally.
	// *********************************************************************
	reader.detachData();
	}
	

// *****************************************************************************
// * cdevMessageBinary::streamIn :
// *	The streamIn function will read a memory buffer provided by the caller 
// *	and then populate the class with these values. This stream remains the 
// *	property of the caller and he is responsible for deleting it.
// *****************************************************************************
int cdevMessageBinary::streamIn ( char *stream, size_t len )
	{
	int      result = -1;
	unsigned packetMap = 0;
			
	// *********************************************************************
	// * Delete the binary data buffer and set its length to 0.
	// *********************************************************************
	if(binary!=NULL) 
		{
		delete binary;
		binary = NULL;
		}
	binaryLen = 0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(stream, len);
	
	// *********************************************************************
	// * Clear the packet map prior to reading data from the stream.
	// *********************************************************************
	map.rawData       = 0;
	
	// *********************************************************************
	// * Read the packet map from the stream.  This object contains a bit
	// * field that identifies the version of the packet and tells what 
	// * other components are embedded in the binary stream.
	// *********************************************************************
	result = !reader.get(packetMap);
	int2map (map, packetMap);
	
	// *********************************************************************
	// * Before processing anything else, the method must ensure that this
	// * packet is of the correct version.  Version 1 for this object.
	// *
	// * Note that reading each field is contingent on the prior fields 
	// * being read correctly.
	// *********************************************************************
	if(!result && map.value.version == CDEV_PACKET_VERSION)
		{		
		binaryLen = len;
		binary    = new char[binaryLen];
		memcpy(binary, stream, binaryLen);
		}
	else result = -1;
	
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *********************************************************************
// * cdevMessageBinary::attachData :
// *	This method allows the caller to assign a preallocated binary
// *	buffer to this object.  This prevents the cdevMessageBinary class
// *	from having to allocate the data.
// *********************************************************************
int cdevMessageBinary::attachData ( char * stream, size_t len )
	{
	int      result = -1;
	unsigned packetMap = 0;			

	// *********************************************************************
	// * Delete the binary data buffer and set its length to 0.
	// *********************************************************************
	if(binary!=NULL) 
		{
		delete binary;
		binary = NULL;
		}
	binaryLen = 0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(stream, len);
	
	// *********************************************************************
	// * Clear the packet map prior to reading data from the stream.
	// *********************************************************************
	map.rawData       = 0;
	
	// *********************************************************************
	// * Read the packet map from the stream.  This object contains a bit
	// * field that identifies the version of the packet and tells what 
	// * other components are embedded in the binary stream.
	// *********************************************************************
	result = !reader.get(packetMap);
	int2map (map, packetMap);
	
	// *********************************************************************
	// * Before processing anything else, the method must ensure that this
	// * packet is of the correct version.  Version 1 for this object.
	// *
	// * Note that reading each field is contingent on the prior fields 
	// * being read correctly.
	// *********************************************************************
	if(!result && map.value.version == CDEV_PACKET_VERSION)
		{		
		binaryLen = len;
		binary = stream;
		}
	else result = -1;
	
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::asciiDump :
// *	This method performs a diagnostic dump of the text representation of the
// *	packets contents.
// *****************************************************************************
void cdevMessageBinary::asciiDump ( FILE * fp )
	{
	short clientID;
	unsigned transIndex, cancelTransIndex, localDataIndex;
	unsigned foreignDataIndex, operationCode, deviceCount;
	int completionCode;
	char **  deviceList;
	char *   message;
	cdevData temp;

	getClientID(clientID);
	getTransIndex(transIndex);
	getCancelTransIndex(cancelTransIndex);
	getLocalDataIndex(localDataIndex);
	getForeignDataIndex(foreignDataIndex);
	getOperationCode (operationCode);
	getCompletionCode (completionCode);
	getDeviceList(deviceList, deviceCount);
	getMessage(message);
	
	fprintf(fp, "----------------------------------------------------------\n");
	fprintf(fp, "             Diagnostic Dump of CDEV Packet\n");
	fprintf(fp, "----------------------------------------------------------\n\n");
	fprintf(fp, "Packet Version     : %i\n", CDEV_PACKET_VERSION);
	fprintf(fp, "Binary Stream Size : %i\n", binaryLen);
	fprintf(fp, "Client Identifier  : %s\n", clientID==-1?"(not specified)":ltoa(clientID));
	fprintf(fp, "Transaction Index  : %s\n", transIndex==0?"(not specified)":ultoa(transIndex));
	fprintf(fp, "Cancel Transaction : %s\n", cancelTransIndex==0?"(not specified)":ultoa(cancelTransIndex));
	fprintf(fp, "Local Data Index   : %s\n", localDataIndex==0?"(not specified)":ultoa(localDataIndex));
	fprintf(fp, "Foreign Data Index : %s\n", foreignDataIndex==0?"(not specified)":ultoa(foreignDataIndex));
	fprintf(fp, "Operation Code     : %s\n", operationCode==0?"(not specified)":ultoa(operationCode));
	fprintf(fp, "Completion Code    : %i\n", completionCode);
	fprintf(fp, "Number of Devices  : %s\n", deviceCount==0?"(not specified)":ultoa(deviceCount));
	fprintf(fp, "List of Devices    : ");
	
	if(deviceCount==0) fprintf(fp, "(not specified)\n");
	else fprintf(fp, "%s\n", deviceList[0]);
	
	for(int i=1; i<deviceCount; i++) 
		{
		fprintf(fp, "                     %s\n", deviceList[i]);
		}

	fprintf(fp, "Message String     : %s\n", message==NULL?"(not specified)":message);

	// *********************************************************************
	// * The deviceList and message string must be deleted.
	// *********************************************************************
	if(deviceList!=NULL)
		{
		for(i=0; i<deviceCount; i++) delete deviceList[i];
		delete deviceList;
		}		
	if(message != NULL) delete message;
	
	int empty;
	
	fprintf(fp, "Data Object        : %s", (empty=getData(temp))==0?"\n":"(not specified)\n");
	fflush(fp);
	if(!empty) temp.asciiDump(fp);
	
	fprintf(fp, "Context Object     : %s", (empty=getContext(temp))==0?"\n":"(not specified)\n");
	fflush(fp);
	if(!empty) temp.asciiDump(fp);
	
	fprintf(fp, "Tag Map            : %s", (empty=getTagMap(temp))==0?"\n":"(not specified)\n");
	if(!empty)
		{
		size_t  tagNumCnt  = 0;
		int  *  tagNums    = NULL;
		size_t  tagNameCnt = 0;
		
		if(temp.getElems(1, &tagNumCnt)==CDEV_SUCCESS  && 
		   temp.getElems(2, &tagNameCnt)==CDEV_SUCCESS &&
		   temp.getType (2)==CDEV_STRING               &&
		   tagNumCnt==tagNameCnt)
			{
			char ** tagNames   = NULL;
			char *  singleName = NULL;
	
			tagNums = new int[tagNumCnt];
			temp.get(1, tagNums);

			if(tagNameCnt==1)
				{
				tagNames = &singleName;
				temp.find(2, (void *&)singleName);
				}
			else temp.find(2, (void *&)tagNames);

			for(int i=0; i<tagNumCnt; i++)
				{
				fprintf(fp, "\t%-26.26s= %i\n", tagNames[i], tagNums[i]);
				} 
			delete tagNums;
			}
		}
	fprintf(fp, "----------------------------------------------------------\n");
	fprintf(fp, "            End of Diagnostic Dump of CDEV Packet\n");
	fprintf(fp, "----------------------------------------------------------\n\n");
	fflush(fp);
	}


// *****************************************************************************
// * cdevMessageBinary::setBinaryPosition :
// *	This method will set the position of the binary stream within an 
// *	XDR_Reader to the specified data object.
// *	This method returns 0 on success, or -1 if the data object could not be
// *	selected.
// *****************************************************************************
int cdevMessageBinary::setBinaryPosition (XDR_Reader & Reader, POSITION_FLAG flag )
	{
	int      slen;
	int      result    = -1;
	unsigned packetMap = 0;

	// *********************************************************************
	// * Set the position to the beginning of the data buffer.
	// *********************************************************************
	xdr_setpos(Reader.xdr(), 0);
			
	// *********************************************************************
	// * Clear the packet map prior to reading data from the stream.
	// *********************************************************************
	map.rawData       = 0;
	
	// *********************************************************************
	// * Read the packet map from the stream.  This object contains a bit
	// * field that identifies the version of the packet and tells what 
	// * other components are embedded in the binary stream.
	// *********************************************************************
	result = !Reader.get(packetMap);
	int2map ( map, packetMap );

	// *********************************************************************
	// * Before processing anything else, the method must ensure that this
	// * packet is of the correct version.  Version 1 for this object.
	// *
	// * Note that reading each field is contingent on the prior fields 
	// * being read correctly.
	// *********************************************************************
	if(!result && map.value.version==CDEV_PACKET_VERSION)
		{		
		// *************************************************************
		// * If the selected element is beyond the clientID, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_CLIENTID)
			{
			if(map.value.clientIDSet!=0)
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((short)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the clientID.
		// *************************************************************
		else if(flag==GOTO_CLIENTID && !map.value.clientIDSet) result=-1;


		// *************************************************************
		// * If the selected element is beyond the transIndex, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_TRANSINDEX)
			{
			if(!result && map.value.transIndexSet!=0)
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((unsigned)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the transIndex.
		// *************************************************************
		else if(flag==GOTO_TRANSINDEX && !map.value.transIndexSet) result=-1;
			
			

		// *************************************************************
		// * If the selected element is beyond the cancelTransIndex, 
		// * then advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_CANCELTRANSINDEX)
			{
			if(!result && map.value.cancelTransIndexSet!=0)
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((unsigned)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the cancelTransIndex.
		// *************************************************************
		else if(flag==GOTO_CANCELTRANSINDEX && !map.value.cancelTransIndexSet) result=-1;
			
			

		// *************************************************************
		// * If the selected element is beyond the localDataIndex, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_LOCALDATAINDEX)
			{
			if(!result && map.value.localDataIndexSet!=0) 
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((unsigned)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the localDataIndex.
		// *************************************************************
		else if(flag==GOTO_LOCALDATAINDEX && !map.value.localDataIndexSet) result=-1;
			
			

		// *************************************************************
		// * If the selected element is beyond the foreignDataIndex, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_FOREIGNDATAINDEX)
			{
			if(!result && map.value.foreignDataIndexSet!=0) 
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((unsigned)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the foreignDataIndex.
		// *************************************************************
		else if(flag==GOTO_FOREIGNDATAINDEX && !map.value.foreignDataIndexSet) result=-1;
			
		

		// *************************************************************
		// * If the selected element is beyond the operationCode, 
		// * then advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_OPERATIONCODE)
			{
			if(!result && map.value.operationCodeSet!=0)
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((unsigned)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the operationCode.
		// *************************************************************
		else if(flag==GOTO_OPERATIONCODE && !map.value.operationCodeSet) result=-1;
			

			
		// *************************************************************
		// * If the selected element is beyond the operationCode, 
		// * then advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_COMPLETIONCODE)
			{
			if(!result && map.value.completionCodeSet!=0)
			    result=!xdr_setpos(
				Reader.xdr(), 
				xdr_getpos(Reader.xdr())+XDR_Sizeof((int)1));
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the operationCode.
		// *************************************************************
		else if(flag==GOTO_COMPLETIONCODE && !map.value.completionCodeSet) result=-1;


		// *************************************************************
		// * If the selected element is beyond the deviceList, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_DEVICELIST)
			{
			if(!result && map.value.deviceListSet!=0)
				{
				int deviceCount;
				if((result = !Reader.get(deviceCount))==0)
					{
					// *************************************
					// * Step over each string in the array.
					// *************************************
					for(int i=0; i<deviceCount && !result; i++)
						{
						slen   = Reader.get_string_len();
						slen   = XDR_Sizeof((char *)NULL, slen);
						result = !xdr_setpos(
								Reader.xdr(), 
								xdr_getpos(Reader.xdr())+slen); 
						}
					}
				}
			}			
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the deviceList.
		// *************************************************************
		else if(flag==GOTO_DEVICELIST && !map.value.deviceListSet) result=-1;
	


		// *************************************************************
		// * If the selected element is beyond the message, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_MESSAGE)
			{
			if(!result && map.value.messageSet!=0)
				{
				slen   = Reader.get_string_len();
				slen   = XDR_Sizeof((char *)NULL, slen);
				result = !xdr_setpos(
						Reader.xdr(), 
						xdr_getpos(Reader.xdr())+slen); 
				}
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the message.
		// *************************************************************
		else if(flag==GOTO_MESSAGE && !map.value.messageSet) result=-1;



		// *************************************************************
		// * If the selected element is beyond the data, then 
		// * advance the buffer to the next item.
		// *************************************************************
		if(flag > GOTO_DATA)
			{
			if(!result && map.value.dataSet!=0)
				{
				slen   = Reader.get_string_len();
				slen   = XDR_Sizeof((void *)NULL, slen);
				result = !xdr_setpos(
						Reader.xdr(), 
						xdr_getpos(Reader.xdr())+slen); 
				}
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the data.
		// *************************************************************
		else if(flag==GOTO_DATA && !map.value.dataSet) result=-1;
		
		
		
		// *************************************************************
		// * If the selected element is beyond the context, then it
		// * contains an invalid value and should be cleared.
		// *************************************************************
		if(flag > GOTO_CONTEXT)
			{
			if(!result && map.value.contextSet!=0)
				{
				slen   = Reader.get_string_len();
				slen   = XDR_Sizeof((void *)NULL, slen);
				result = !xdr_setpos(
						Reader.xdr(), 
						xdr_getpos(Reader.xdr())+slen); 
				}			
			}
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the context.
		// *************************************************************
		else if(flag==GOTO_CONTEXT && !map.value.contextSet) result=-1;


		// *************************************************************
		// * If the selected element is beyond the context, then it
		// * contains an invalid value and should be cleared.
		// *************************************************************
		if(flag > GOTO_TAGMAP) result = -1;
		// *************************************************************
		// * Otherwise... set the result to indicate the existence (or
		// * non-existence) of the context.
		// *************************************************************
		else if(flag==GOTO_TAGMAP && !map.value.tagMapSet) result=-1;
		}

	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::set :
// *	This method will convert the user provided data into the binary stream.
// *****************************************************************************
void cdevMessageBinary::set ( short            clientID, 
			      unsigned         transIndex, 
			      unsigned         cancelTransIndex,
			      unsigned         localDataIndex, 
			      unsigned         foreignDataIndex,
			      unsigned         operationCode,
			      int              completionCode,
			      unsigned         deviceCount,
			      char **          deviceList,
			      char *           message,
			      cdevData *       data,
			      cdevData *       context,
			      cdevData *       tagMap)
	{
	unsigned packetMap  = 0;
	size_t   dataLen    = 0, dataCnt    = 0;
	size_t   contextLen = 0, contextCnt = 0;
	size_t   tagMapLen  = 0, tagMapCnt  = 0;
	
	if(binary!=NULL) 
		{
		delete binary;
		binary = NULL;
		}
	binaryLen = 0;
	
	// *********************************************************************
	// * Construct the packet map to indicate which components will be 
	// * transmitted.
	// *********************************************************************
	map.rawData       = 0;
	map.value.version = CDEV_PACKET_VERSION;
	
	// *********************************************************************
	// * Because the cdevPacketBinary relies on the ordered existance of the
	// * client identifier... this entry will automatically be tagged as 
	// * present, even though it may contain a default value...
	// *********************************************************************
	map.value.clientIDSet = 1;
	
	// *********************************************************************
	// * All other components will only be marked as present if they have 
	// * actually been specified.
	// *********************************************************************
	if(transIndex > 0)                    map.value.transIndexSet = 1;
	if(cancelTransIndex > 0)              map.value.cancelTransIndexSet = 1;
	if(localDataIndex > 0)                map.value.localDataIndexSet = 1;
	if(foreignDataIndex > 0)              map.value.foreignDataIndexSet = 1;
	if(operationCode > 0)                 map.value.operationCodeSet = 1;
	if(completionCode != 0)               map.value.completionCodeSet = 1;
	if(deviceCount>0 && deviceList!=NULL) map.value.deviceListSet = 1;
	if(message!=NULL)                     map.value.messageSet = 1;
	
	if(data!=NULL)    data->xdrSize   (&dataLen, &dataCnt);
	if(context!=NULL) context->xdrSize(&contextLen, &contextCnt);
	if(tagMap!=NULL)  tagMap->xdrSize (&tagMapLen, &tagMapCnt);
	
	if(dataCnt > 0)                       map.value.dataSet = 1;
	if(contextCnt > 0)                    map.value.contextSet = 1;
	if(tagMapCnt > 0)                     map.value.tagMapSet = 1;
	
	// *********************************************************************
	// * Calculate the total size of the packet.
	// *********************************************************************
	binaryLen = XDR_Sizeof( map2int(map, packetMap) );
	if(map.value.clientIDSet!=0)             binaryLen += XDR_Sizeof(clientID);
	if(map.value.transIndexSet!=0)           binaryLen += XDR_Sizeof(transIndex);
	if(map.value.cancelTransIndexSet!=0)     binaryLen += XDR_Sizeof(cancelTransIndex);
	if(map.value.localDataIndexSet!=0)       binaryLen += XDR_Sizeof(localDataIndex);
	if(map.value.foreignDataIndexSet!=0)     binaryLen += XDR_Sizeof(foreignDataIndex);
	if(map.value.operationCodeSet!=0)        binaryLen += XDR_Sizeof(operationCode);
	if(map.value.completionCodeSet!=0)       binaryLen += XDR_Sizeof(completionCode);
	if(map.value.deviceListSet!=0)
		{
		binaryLen += XDR_Sizeof(deviceCount);
		for(int i=0; i<deviceCount; i++) binaryLen += XDR_Sizeof(deviceList[i]);
		}
	if(map.value.messageSet!=0)              binaryLen += XDR_Sizeof(message);
	if(map.value.dataSet!=0)
		{
		binaryLen += XDR_Sizeof((void *)NULL, dataLen);
		}
	if(map.value.contextSet!=0)
		{
		binaryLen += XDR_Sizeof((void *)NULL, contextLen);
		}
	if(map.value.tagMapSet!=0)
		{
		binaryLen += XDR_Sizeof((void *)NULL, tagMapLen);
		}
		
	// *********************************************************************
	// * Allocate the packet and then write the data items into it.
	// *********************************************************************
	XDR_Writer writer;
	unsigned   position = 0;
	
	binary = new char[binaryLen];
	writer.attachData(binary, binaryLen);
	writer.put(packetMap);
	if(map.value.clientIDSet!=0)             writer.put(clientID);
	if(map.value.transIndexSet!=0)           writer.put(transIndex);
	if(map.value.cancelTransIndexSet!=0)     writer.put(cancelTransIndex);
	if(map.value.localDataIndexSet!=0)       writer.put(localDataIndex);
	if(map.value.foreignDataIndexSet!=0)     writer.put(foreignDataIndex);
	if(map.value.operationCodeSet!=0)        writer.put(operationCode);
	if(map.value.completionCodeSet!=0)       writer.put(completionCode);
	if(map.value.deviceListSet!=0)
		{
		writer.put(deviceCount);
		for(int i=0; i<deviceCount; i++) writer.put((char *)deviceList[i]);
		}
	if(map.value.messageSet!=0)              writer.put((char *)message);

	// *********************************************************************
	// * This is an experimental insertion that allows me to place the data
	// * into the xdr buffer directly without having to preallocate a buffer.
	// *********************************************************************
	char * tbuf;
	int    tpos;

	if(map.value.dataSet!=0) 
		{
		tpos = xdr_getpos(writer.xdr());
		writer.put(dataLen);
		tbuf = writer.buffer()+xdr_getpos(writer.xdr());
		data->xdrExport(tbuf, dataLen, dataCnt);
		xdr_setpos(writer.xdr(), tpos+XDR_Sizeof((void *)NULL, dataLen));
		}
	if(map.value.contextSet!=0)
		{
		tpos = xdr_getpos(writer.xdr());
		writer.put(contextLen);
		tbuf = writer.buffer()+xdr_getpos(writer.xdr());
		context->xdrExport(tbuf, contextLen, contextCnt);
		xdr_setpos(writer.xdr(), tpos+XDR_Sizeof((void *)NULL, contextLen));
		}
	if(map.value.tagMapSet!=0)
		{
		tpos = xdr_getpos(writer.xdr());
		writer.put(tagMapLen);
		tbuf = writer.buffer()+xdr_getpos(writer.xdr());
		tagMap->xdrExport(tbuf, tagMapLen, tagMapCnt);
		xdr_setpos(writer.xdr(), tpos+XDR_Sizeof((void *)NULL, tagMapLen));
		}

	writer.detachData();
	}


// *****************************************************************************
// * cdevMessageBinary::getVersion :
// *	This method is used to obtain the version number of the packet.
// *****************************************************************************
int cdevMessageBinary::getVersion ( short & version )
	{
	version = CDEV_PACKET_VERSION;
	return 0;
	}


// *****************************************************************************
// * cdevMessageBinary::getClientID :
// *	This method is used to obtain the client identifier for the packet.
// *	This method returns 0 on success, or -1 if the clientID was not
// *	specified.
// *****************************************************************************
int cdevMessageBinary::getClientID ( short & clientID )
	{
	int  result = -1;
	clientID    = -1;
			
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_CLIENTID))==0)
		{
		if(map.value.clientIDSet!=0)  result=!reader.get(clientID);
		}

	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


	
// *****************************************************************************
// * cdevMessageBinary::getTransIndex :
// *	This method is used to obtain the transaction object index.  This
// *	object is used on the client side to obtain a pointer to the transaction
// *	object.
// *	This method returns 0 on success, or -1 if the transIndex could not
// *	be read.
// *****************************************************************************
int cdevMessageBinary::getTransIndex ( unsigned & transIndex )
	{
	int    result = -1;
	transIndex    = 0;
			
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_TRANSINDEX))==0)
		{
		result = !reader.get(transIndex);
		}

	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getCancelTransIndex :
// *	This method is used to obtain the identifier of a transaction object
// *	that is to be canceled.
// *
// *	This method returns 0 on success, or -1 if the cancelCancelTransIndex could not
// *	be read.
// *****************************************************************************
int cdevMessageBinary::getCancelTransIndex ( unsigned & cancelTransIndex )
	{
	int result       = -1;
	cancelTransIndex = 0;
			
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_CANCELTRANSINDEX))==0)
		{
		result = !reader.get(cancelTransIndex);
		}

	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getLocalDataIndex :
// *	This method is used to obtain an index to any data that may be 
// *	maintained on the senders side of the connection.
// *	This method returns 0 on success, or -1 if the localDataIndex could 
// *	not be read.
// *****************************************************************************
int cdevMessageBinary::getLocalDataIndex ( unsigned & localDataIndex )
	{
	int    result  = -1;
	localDataIndex =  0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_LOCALDATAINDEX))==0)
		{
		result = !reader.get(localDataIndex);
		}
		
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getForeignDataIndex :
// *	This method is used to obtain an index to any data that may be 
// *	maintained on the senders side of the connection.
// *	This method returns 0 on success, or -1 if the foreignDataIndex could 
// *	not be read.
// *****************************************************************************
int cdevMessageBinary::getForeignDataIndex ( unsigned & foreignDataIndex )
	{
	int    result    = -1;
	foreignDataIndex = 0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_FOREIGNDATAINDEX))==0)
		{
		result = !reader.get(foreignDataIndex);
		}
		
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getOperationCode :
// *	This method is used to obtain the operation code.  An operation code may
// *	be used by the developer to define a particular message.  This is faster
// *	to manipulate than the supported string messages.
// *****************************************************************************
int cdevMessageBinary::getOperationCode ( unsigned & operationCode )
	{
	int result         = -1;
	operationCode = 0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_OPERATIONCODE))==0)
		{
		result = !reader.get(operationCode);
		}
		
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getCompletionCode :
// *	This method is used to obtain the completion code.  The completion code
// *	is returned by the server to indicate the result code from an operation.
// *****************************************************************************
int cdevMessageBinary::getCompletionCode ( int & completionCode )
	{
	int result         = -1;
	completionCode = 0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_COMPLETIONCODE))==0)
		{
		result = !reader.get(completionCode);
		}
		
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}

// *****************************************************************************
// * cdevMessageBinary::getDeviceList :
// *	This method is used to obtains an array of device names that are 
// *	associated with the request.  It is the responsibility of the caller
// *	to delete each element of the array, and the array itself when they
// *	are no longer needed.
// *	This method returns 0 on success, or -1 if the deviceList could 
// *	not be read.
// *****************************************************************************
int cdevMessageBinary::getDeviceList ( char ** & deviceList, unsigned & deviceCount)
	{
	int    result = -1;

	deviceList  = NULL;
	deviceCount = 0;

	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_DEVICELIST))==0)
		{
		if((result = !reader.get(deviceCount))==0)
			{
			// *********************************************
			// * Allocate and initialize an array sufficient
			// * to hold the contents of the stream.
			// *********************************************
			deviceList = new char * [deviceCount];
			memset(deviceList, 0, sizeof(char *)*deviceCount);

			// *********************************************
			// * Read the individual strings into the array.
			// * Note that the XDR_Reader will automatically
			// * allocate data if the pointers are set to 
			// * NULL.
			// *********************************************
			for(int i=0; i<deviceCount && !result; i++)
				result = !reader.get(&deviceList[i]);
			}

		// *****************************************************
		// * In event that a failure occurred after the buffer
		// * was allocated.  Walk through the array and free
		// * each data item... then free the array.
		// *****************************************************
		if(result!=0 && deviceList!=NULL)
			{
			for(int i=0; i<deviceCount; i++)
				{
				if(deviceList[i]!=NULL) delete deviceList[i];
				}
			delete deviceList;
			}
		}
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getMessage :
// *	This method is used to obtains an array of device names that are 
// *	associated with the request.  It is the responsibility of the caller
// *	to delete each element of the array, and the array itself when they
// *	are no longer needed.
// *	This method returns 0 on success, or -1 if the deviceList could 
// *	not be read.
// *****************************************************************************
int cdevMessageBinary::getMessage ( char * & message)
	{
	int result = -1;
	message    = NULL;
	
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_MESSAGE))==0)
		{
		if((result = !reader.get(&message))!=0)
			{
			delete message;
			}		
		}
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getData :
// *	This method is used to read the data cdevData object from the 
// *	binary stream.
// *	This method returns 0 on success, or -1 if the data item could 
// *	not be read.
// *****************************************************************************
int cdevMessageBinary::getData ( cdevData & data)
	{
	int    result = -1;

	// *********************************************************************
	// * Clear the contents of the context data object.
	// *********************************************************************
	data.remove();
		
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_DATA))==0)
		{
		int   tlen;
		int   tpos;
		char *tbuf;

		tpos = xdr_getpos(reader.xdr());
		reader.get(tlen);
		tbuf = reader.buffer()+xdr_getpos(reader.xdr());
		if(tlen!=0 && tbuf!=NULL) data.xdrImport(tbuf, tlen);
		else result = -1;
		xdr_setpos(reader.xdr(), tpos+XDR_Sizeof((void *)NULL, tlen));	
		}
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getContext :
// *	This method is used to read the context cdevData object from the 
// *	binary stream.
// *	This method returns 0 on success, or -1 if the context could 
// *	not be read.
// *****************************************************************************
int cdevMessageBinary::getContext ( cdevData & context)
	{
	int    result = -1;

	// *********************************************************************
	// * Clear the contents of the context data object.
	// *********************************************************************
	context.remove();
		
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_CONTEXT))==0)
		{
		int   tlen;
		int   tpos;
		char *tbuf;

		tpos = xdr_getpos(reader.xdr());
		reader.get(tlen);
		tbuf = reader.buffer()+xdr_getpos(reader.xdr());
		if(tlen!=0 && tbuf!=NULL) context.xdrImport(tbuf, tlen);
		else result = -1;
		xdr_setpos(reader.xdr(), tpos+XDR_Sizeof((void *)NULL, tlen));
		}
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::getTagMap :
// *	This method is used to read the tagMap cdevData object from the 
// *	binary stream.
// *	This method returns 0 on success, or -1 if the tagMap could not be read.
// *****************************************************************************
int cdevMessageBinary::getTagMap ( cdevData & tagMap)
	{
	int    result = -1;

	// *********************************************************************
	// * Clear the contents of the tagMap data object.
	// *********************************************************************
	tagMap.remove();
		
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);
	
	// *********************************************************************
	// * Reposition the binary structure to point to the correct location
	// * and read the data item.
	// *********************************************************************
	if((result = setBinaryPosition(reader, GOTO_TAGMAP))==0)
		{
		int   tlen;
		int   tpos;
		char *tbuf;

		tpos = xdr_getpos(reader.xdr());
		reader.get(tlen);
		tbuf = reader.buffer()+xdr_getpos(reader.xdr());
		if(tlen!=0 && tbuf!=NULL) tagMap.xdrImport(tbuf, tlen);
		else result = -1;
		xdr_setpos(reader.xdr(), tpos+XDR_Sizeof((void *)NULL, tlen));
		}
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}


// *****************************************************************************
// * cdevMessageBinary::get :
// *	This method is used to read the complete contents of the packet.
// *	This method returns 0 on success, or -1 if the deviceList could 
// *	not be read.
// *
// *	Note that all data items allocated by this call become the property of
// *	the caller and must be deleted.  Specifically, the deviceList and
// *	message parameters must be deleted.
// *****************************************************************************
int cdevMessageBinary::get ( short    & clientID, 
			     unsigned & transIndex,
			     unsigned & cancelTransIndex,
			     unsigned & localDataIndex,
			     unsigned & foreignDataIndex,
			     unsigned & operationCode,
			     int      & completionCode,
			     unsigned & deviceCount,
			     char **  & deviceList,
			     char *   & message,
			     cdevData & data,
			     cdevData & context,
			     cdevData & tagMap)
	{
	int      result = -1;
	unsigned packetMap = 0;

	// *********************************************************************
	// * Set all data to a default value.
	// *********************************************************************
	clientID         = -1;
	transIndex       = 0;
	cancelTransIndex = 0;
	localDataIndex   = 0;
	foreignDataIndex = 0;
	operationCode    = 0;
	completionCode   = 0;
	deviceCount      = 0;
	deviceList       = NULL;
	message          = NULL;
	data.remove();
	context.remove();
	tagMap.remove();
		
	// *********************************************************************
	// * Attach the data to the XDR_Reader class so that its components
	// * can be extracted.
	// *********************************************************************
	reader.attachData(binary, binaryLen);

	// *********************************************************************
	// * Set the position to the beginning of the data buffer.
	// *********************************************************************
	xdr_setpos(reader.xdr(), 0);
			
	// *********************************************************************
	// * Clear the packet map prior to reading data from the stream.
	// *********************************************************************
	map.rawData       = 0;
	
	// *********************************************************************
	// * Read the packet map from the stream.  This object contains a bit
	// * field that identifies the version of the packet and tells what 
	// * other components are embedded in the binary stream.
	// *********************************************************************
	if((result = !reader.get(packetMap))==0)
		{
		int2map(map, packetMap);
		}
	
	// *********************************************************************
	// * Before processing anything else, the method must ensure that this
	// * packet is of the correct version.  Version 1 for this object.
	// *
	// * Note that reading each field is contingent on the prior fields 
	// * being read correctly.
	// *********************************************************************
	if(!result && map.value.version!=CDEV_PACKET_VERSION) result=-1;
	if(!result && map.value.clientIDSet!=0)  result=!reader.get(clientID);
	if(!result && map.value.transIndexSet!=0) result = !reader.get(transIndex);
	if(!result && map.value.cancelTransIndexSet!=0) result = !reader.get(cancelTransIndex);
	if(!result && map.value.localDataIndexSet!=0) result = !reader.get(localDataIndex);
	if(!result && map.value.foreignDataIndexSet!=0) result = !reader.get(foreignDataIndex);
	if(!result && map.value.operationCodeSet!=0) result = !reader.get(operationCode);
	if(!result && map.value.completionCodeSet!=0) result = !reader.get(completionCode);
	if(!result && map.value.deviceListSet!=0)
		{
		if((result = !reader.get(deviceCount))==0)
			{
			// *********************************************
			// * Allocate and initialize an array sufficient
			// * to hold the contents of the stream.
			// *********************************************
			deviceList = new char * [deviceCount];
			memset(deviceList, 0, sizeof(char *)*deviceCount);

			// *********************************************
			// * Read the individual strings into the array.
			// * Note that the XDR_Reader will automatically
			// * allocate data if the pointers are set to 
			// * NULL.
			// *********************************************
			for(int i=0; i<deviceCount && !result; i++)
				result = !reader.get(&deviceList[i]);
			}
		}
	if(!result && map.value.messageSet!=0) result = !reader.get(&message);

	// *********************************************************************
	// * This mechanism will bypass the standard XDR extractor and allow
	// * the caller to directly read the data from the stream without
	// * performing an additional memory allocation.
	// *********************************************************************
	int   tlen;
	int   tpos;
	char *tbuf;

	if(!result && map.value.dataSet!=0)
		{
		tpos = xdr_getpos(reader.xdr());
		reader.get(tlen);
		tbuf = reader.buffer()+xdr_getpos(reader.xdr());
		if(tlen!=0 && tbuf!=NULL) data.xdrImport(tbuf, tlen);
		else result = -1;
		xdr_setpos(reader.xdr(), tpos+XDR_Sizeof((void *)NULL, tlen));
		}
	if(!result && map.value.contextSet) 
		{
		tpos = xdr_getpos(reader.xdr());
		reader.get(tlen);
		tbuf = reader.buffer()+xdr_getpos(reader.xdr());
		if(tlen!=0 && tbuf!=NULL) context.xdrImport(tbuf, tlen);
		else result = -1;
		xdr_setpos(reader.xdr(), tpos+XDR_Sizeof((void *)NULL, tlen));
		}
	if(!result && map.value.tagMapSet) 
		{
		tpos = xdr_getpos(reader.xdr());
		reader.get(tlen);
		tbuf = reader.buffer()+xdr_getpos(reader.xdr());
		if(tlen!=0 && tbuf!=NULL) tagMap.xdrImport(tbuf, tlen);
		else result = -1;
		xdr_setpos(reader.xdr(), tpos+XDR_Sizeof((void *)NULL, tlen));
		}

	// *****************************************************
	// * In event that a failure occurred after the buffers
	// * was allocated.  Walk through the array and free
	// * each data item... then free the array.
	// *****************************************************
	if(result!=0)
		{
		if(deviceList!=NULL)
			{
			for(int i=0; i<deviceCount; i++)
				{
				if(deviceList[i]!=NULL) delete deviceList[i];
				}
			delete deviceList;
			deviceList = NULL;
			}
		if(message!=NULL) 
			{
			delete message;
			message = NULL;
			}
		clientID         = -1;
		transIndex       = 0;
		localDataIndex   = 0;
		foreignDataIndex = 0;
		operationCode    = 0;
		completionCode   = 0;
		deviceCount      = 0;
		data.remove();
		context.remove();
		tagMap.remove();
		}
	
	// *********************************************************************
	// * Detach the binary buffer from the XDR_Reader to prevent it from 
	// * being deleted when the XDR_Reader class is destroyed.
	// *********************************************************************
	reader.detachData();
	
	return result;
	}