311 lines
11 KiB
C++
Executable File
311 lines
11 KiB
C++
Executable File
#include <cdevMessage.h>
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::import :
|
|
// * This metod is used by the cdevPacket class to generate a cdevMessage
|
|
// * object from a cdevBinaryPacket object. In order for the cdevPacket
|
|
// * class to perform this task, the import method and the
|
|
// * CDEV_PACKET_VERSION must be registered using the
|
|
// * cdevPacket::registerImportMethod function.
|
|
// *****************************************************************************
|
|
cdevPacket * cdevMessage::import( cdevPacketBinary & packet)
|
|
{
|
|
char * binary = NULL;
|
|
size_t binaryLen = 0;
|
|
|
|
packet.streamOut(&binary, &binaryLen);
|
|
|
|
return new cdevMessage(binary, binaryLen);
|
|
}
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::cdevMessage :
|
|
// * This is a parameterized constructor for the cdevMessage object. If none
|
|
// * of the parameters are specified then this constructor will build a
|
|
// * cdevMessage object made completely from defaults.
|
|
// *****************************************************************************
|
|
cdevMessage::cdevMessage ( 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)
|
|
: clientID (ClientID),
|
|
transIndex (TransIndex),
|
|
cancelTransIndex (CancelTransIndex),
|
|
localDataIndex (LocalDataIndex),
|
|
foreignDataIndex (ForeignDataIndex),
|
|
operationCode (OperationCode),
|
|
completionCode (CompletionCode),
|
|
deviceCount (DeviceCount),
|
|
deviceList (NULL),
|
|
message (NULL),
|
|
data (NULL),
|
|
context (NULL),
|
|
tagMap (NULL)
|
|
{
|
|
saveTbl.rawData=0;
|
|
|
|
if(DeviceCount>0 && DeviceList!=NULL)
|
|
{
|
|
deviceList = (char **)new char * [deviceCount];
|
|
for(int i=0; i<deviceCount; i++)
|
|
{
|
|
deviceList[i] = strdup(DeviceList[i]);
|
|
}
|
|
}
|
|
if(Message!=NULL) message = strdup(Message);
|
|
if(Data!=NULL) data = new cdevData(*Data);
|
|
if(Context!=NULL) context = new cdevData(*Context);
|
|
if(TagMap!=NULL) tagMap = new cdevData(*TagMap);
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::cdevMessage :
|
|
// * This is the constructor for the object. It serves to initialize the
|
|
// * internals of the object with default values or the user specified
|
|
// * binary data if provided.
|
|
// *****************************************************************************
|
|
cdevMessage::cdevMessage ( char * binary, size_t binaryLen )
|
|
: deviceCount(0), deviceList(NULL), message(NULL),
|
|
data(NULL), context(NULL), tagMap(NULL)
|
|
{
|
|
saveTbl.rawData = 0;
|
|
streamIn(binary, binaryLen);
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::cdevMessage :
|
|
// * This is the copy constructor for the object. It creates a new
|
|
// * cdevMessage object that contains all of the data specified in the
|
|
// * user provided object.
|
|
// *****************************************************************************
|
|
cdevMessage::cdevMessage ( cdevMessage & Message )
|
|
: clientID (Message.clientID),
|
|
transIndex (Message.transIndex),
|
|
cancelTransIndex (Message.cancelTransIndex),
|
|
localDataIndex (Message.localDataIndex),
|
|
foreignDataIndex (Message.foreignDataIndex),
|
|
operationCode (Message.operationCode),
|
|
completionCode (Message.completionCode),
|
|
deviceCount (Message.deviceCount),
|
|
deviceList (NULL),
|
|
message (NULL),
|
|
data (NULL),
|
|
context (NULL),
|
|
tagMap (NULL)
|
|
{
|
|
saveTbl.rawData = 0;
|
|
if(Message.deviceCount>0 && Message.deviceList!=NULL)
|
|
{
|
|
deviceList = (char **)new char * [deviceCount];
|
|
for(int i=0; i<deviceCount; i++)
|
|
{
|
|
deviceList[i] = strdup(Message.deviceList[i]);
|
|
}
|
|
}
|
|
if(Message.message!=NULL) message = strdup(Message.message);
|
|
if(Message.data!=NULL) data = new cdevData(*Message.data);
|
|
if(Message.context!=NULL) context = new cdevData(*Message.context);
|
|
if(Message.tagMap!=NULL) tagMap = new cdevData(*Message.tagMap);
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::~cdevMessage :
|
|
// * This is the destructor for the class. It releases any previously
|
|
// * allocated memory prior to the destruction of the object.
|
|
// *****************************************************************************
|
|
cdevMessage::~cdevMessage ( void )
|
|
{
|
|
clear();
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::clear :
|
|
// * This is the clear mechanism for the object. It is used to deallocate
|
|
// * any memory that has been allocated and set all data items to their
|
|
// * initial default values.
|
|
// *****************************************************************************
|
|
void cdevMessage::clear ( void )
|
|
{
|
|
setClientID(-1);
|
|
setTransIndex(0);
|
|
setCancelTransIndex(0);
|
|
setLocalDataIndex(0);
|
|
setForeignDataIndex(0);
|
|
setOperationCode(0);
|
|
setCompletionCode(0);
|
|
setDeviceList(NULL, 0, 0);
|
|
setMessage(NULL);
|
|
setData(NULL);
|
|
setContext(NULL);
|
|
setTagMap(NULL);
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::streamIn :
|
|
// * This mechanism is used to use a binary packet to populate the
|
|
// * cdevMessage object.
|
|
// *
|
|
// * The binary stream remains the property of the caller and must be
|
|
// * delete by him.
|
|
// *****************************************************************************
|
|
int cdevMessage::streamIn( char * binary, size_t binaryLen )
|
|
{
|
|
int result = 0;
|
|
cdevMessageBinary packet;
|
|
|
|
clear();
|
|
packet.attachData(binary, binaryLen);
|
|
if(packet.hasClientID()) result+=packet.getClientID(clientID);
|
|
if(packet.hasTransIndex()) result+=packet.getTransIndex(transIndex);
|
|
if(packet.hasCancelTransIndex()) result+=packet.getCancelTransIndex(cancelTransIndex);
|
|
if(packet.hasLocalDataIndex()) result+=packet.getLocalDataIndex(localDataIndex);
|
|
if(packet.hasForeignDataIndex()) result+=packet.getForeignDataIndex(foreignDataIndex);
|
|
if(packet.hasOperationCode()) result+=packet.getOperationCode(operationCode);
|
|
if(packet.hasCompletionCode()) result+=packet.getCompletionCode(completionCode);
|
|
if(packet.hasDeviceList()) result+=packet.getDeviceList(deviceList, deviceCount);
|
|
if(packet.hasMessage()) result+=packet.getMessage(message);
|
|
if(packet.hasData())
|
|
{
|
|
data = new cdevData;
|
|
result+=packet.getData(*data);
|
|
}
|
|
if(packet.hasContext())
|
|
{
|
|
context = new cdevData;
|
|
result+=packet.getContext(*context);
|
|
}
|
|
if(packet.hasTagMap())
|
|
{
|
|
tagMap = new cdevData;
|
|
result+=packet.getTagMap(*tagMap);
|
|
}
|
|
packet.detachData();
|
|
return result;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::streamOut :
|
|
// * This mechanism is used to generate a binary representation of the
|
|
// * cdevMessage object.
|
|
// *
|
|
// * The binary stream becomes the property of the caller and he must delete
|
|
// * it when it is no longer needed.
|
|
// *****************************************************************************
|
|
int cdevMessage::streamOut( char ** binary, size_t * binaryLen )
|
|
{
|
|
cdevMessageBinary packet;
|
|
|
|
packet.set(clientID, transIndex, cancelTransIndex,
|
|
localDataIndex, foreignDataIndex, operationCode,
|
|
completionCode, deviceCount, deviceList,
|
|
message, data, context, tagMap);
|
|
packet.streamOut (binary, binaryLen);
|
|
packet.detachData();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
// * cdevMessage::asciiDump :
|
|
// * This mechanism is included to provide the ability to generate a
|
|
// * diagnostic dump of the cdevMessage object.
|
|
// *****************************************************************************
|
|
void cdevMessage::asciiDump ( FILE * fp )
|
|
{
|
|
fprintf(fp, "----------------------------------------------------------\n");
|
|
fprintf(fp, " Diagnostic Dump of CDEV Message\n");
|
|
fprintf(fp, "----------------------------------------------------------\n\n");
|
|
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, "Save Table :\n");
|
|
fprintf(fp, " Device List %s Permanent\n", saveTbl.value.saveDeviceList?"IS":"IS NOT");
|
|
fprintf(fp, " Message %s Permanent\n", saveTbl.value.saveMessage?"IS":"IS NOT");
|
|
fprintf(fp, " Data %s Permanent\n", saveTbl.value.saveData?"IS":"IS NOT");
|
|
fprintf(fp, " Context %s Permanent\n", saveTbl.value.saveContext?"IS":"IS NOT");
|
|
fprintf(fp, " Tag Map %s Permanent\n", saveTbl.value.saveTagMap?"IS":"IS NOT");
|
|
|
|
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);
|
|
|
|
fprintf(fp, "Data Object : %s", data!=NULL?"\n":"(not specified)\n");
|
|
fflush(fp);
|
|
if(data) data->asciiDump(fp);
|
|
|
|
fprintf(fp, "Context Object : %s", context!=NULL?"\n":"(not specified)\n");
|
|
fflush(fp);
|
|
if(context) context->asciiDump(fp);
|
|
|
|
fprintf(fp, "Tag Map : %s", tagMap!=NULL?"\n":"(not specified)\n");
|
|
if(tagMap)
|
|
{
|
|
size_t tagNumCnt = 0;
|
|
int * tagNums = NULL;
|
|
size_t tagNameCnt = 0;
|
|
char ** tagNames = NULL;
|
|
|
|
if(tagMap->getElems(1, &tagNumCnt)==CDEV_SUCCESS &&
|
|
tagMap->getElems(2, &tagNameCnt)==CDEV_SUCCESS &&
|
|
tagMap->getType (2)==CDEV_STRING &&
|
|
tagNumCnt==tagNameCnt)
|
|
{
|
|
char ** tagNames = NULL;
|
|
char * singleName = NULL;
|
|
|
|
tagNums = new int[tagNumCnt];
|
|
tagMap->get(1, tagNums);
|
|
|
|
if(tagNameCnt==1)
|
|
{
|
|
tagNames = &singleName;
|
|
tagMap->find(2, (void *&)singleName);
|
|
}
|
|
else tagMap->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 Message\n");
|
|
fprintf(fp, "----------------------------------------------------------\n\n");
|
|
fflush(fp);
|
|
}
|
|
|
|
|