DCM_OBJECT *
createQueryObject(const char *fileName)
{
DCM_OBJECT *obj;
CONDITION cond;
DCM_ELEMENT e;
char txt[1024] = "";
int group = 0;
int element = 0;
char textValue[1024];
if (fileName != NULL) {
cond = DCM_OpenFile(fileName, DCM_ORDERLITTLEENDIAN, &obj);
if (cond != DCM_NORMAL) {
COND_DumpConditions();
exit(1);
}
return obj;
}
cond = DCM_CreateObject(&obj, 0);
if (cond != DCM_NORMAL) {
COND_DumpConditions();
exit(1);
}
while (fgets(txt, sizeof(txt), stdin) != NULL) {
if (txt[0] == '#' || txt[0] == '\0')
continue;
if (txt[0] == '\n' || txt[0] == '\r')
continue;
if (sscanf(txt, "%x %x %[^\n]", &group, &element, textValue) != 3)
continue;
e.tag = DCM_MAKETAG(group, element);
DCM_LookupElement(&e);
if (strncmp(textValue, "#", 1) == 0) {
e.length = 0;
e.d.string = NULL;
} else {
e.length = strlen(textValue);
e.d.string = textValue;
}
cond = DCM_AddElement(&obj, &e);
if (cond != DCM_NORMAL) {
COND_DumpConditions();
exit(1);
}
}
return obj;
}
static void readTags(istream& i, tagVector& v)
{
char buf[1024];
while(i.getline(buf, sizeof(buf))) {
if ((buf[0] == '#' || buf[0] == '\n'))
continue;
int i1 = 0, i2 = 0;
::sscanf(buf, "%x %x", &i1, &i2);
DCM_TAG tag = DCM_MAKETAG(i1, i2);
v.push_back(tag);
}
}
static void
groupCallback(unsigned short group, char *description, void *ctx)
{
DCM_ELEMENT_NODE *n;
LST_HEAD **l;
l = (LST_HEAD **) ctx;
n = calloc(1, sizeof(*n));
if (n == NULL)
return;
n->e.tag = DCM_MAKETAG(group, 0);
strcpy(n->e.description, description);
(void) LST_Enqueue(l, n);
}
void
MLQueryUPS::inflateScheduledStationNameCodeSequence(DCM_OBJECT* obj)
{
LST_HEAD* l1 = 0;
CONDITION cond = ::DCM_GetSequenceList(&obj,
DCM_MAKETAG(0x0040, 0x4025),
&l1);
if (cond != DCM_NORMAL) {
::COND_PopCondition(TRUE);
return;
}
DCM_SEQUENCE_ITEM* item = (DCM_SEQUENCE_ITEM*) ::LST_Head(&l1);
if (item == NULL) {
item = (DCM_SEQUENCE_ITEM*) ::malloc(sizeof(*item));
::DCM_CreateObject(&item->object, 0);
MDICOMWrapper w(item->object);
w.setString(DCM_IDCODEVALUE, "");
w.setString(DCM_IDCODINGSCHEMEDESIGNATOR, "");
w.setString(DCM_IDCODEMEANING, "");
::LST_Enqueue(&l1, item);
} else {
bool emptyFlag = true;
MDICOMWrapper w3(item->object);
if (w3.attributePresent(DCM_IDCODEVALUE))
emptyFlag = false;
if (w3.attributePresent(DCM_IDCODINGSCHEMEDESIGNATOR))
emptyFlag = false;
if (w3.attributePresent(DCM_IDCODEMEANING))
emptyFlag = false;
if (emptyFlag) { // Then none of these are included
w3.setString(DCM_IDCODEVALUE, "");
w3.setString(DCM_IDCODINGSCHEMEDESIGNATOR, "");
w3.setString(DCM_IDCODEMEANING, "");
}
}
}
CONDITION
MSG_ParseCMoveResponse(DCM_OBJECT ** object, MSG_C_MOVE_RESP * moveResponse)
{
static MSG_C_MOVE_RESP response;
static unsigned short command, type;
static DCM_ELEMENT elementList[] = {
{DCM_GROUPCOMMAND, DCM_CMDCOMMANDFIELD, DCM_US, "", 1, sizeof(command), (void *) &command},
{DCM_GROUPCOMMAND, DCM_CMDCLASSUID, DCM_UI, "", 1, sizeof(response.classUID), (void *) response.classUID},
{DCM_GROUPCOMMAND, DCM_CMDMSGIDRESPOND, DCM_US, "", 1, sizeof(response.messageIDRespondedTo), (void *) &response.messageIDRespondedTo},
{DCM_GROUPCOMMAND, DCM_CMDDATASETTYPE, DCM_US, "", 1, sizeof(type), (void *) &type},
{DCM_GROUPCOMMAND, DCM_CMDSTATUS, DCM_US, "", 1, sizeof(response.status), (void *) &response.status},
};
DCM_ELEMENT e; /* Used for conditional elements */
static MSGPRV_CONDITIONAL conditionalList[] = {
{DCM_GROUPCOMMAND, DCM_CMDSUCCESSINSTANCEUIDLIST, DCM_UI, "", 1, 0, (void *) &response.successUIDs, &response.conditionalFields, MSG_K_C_MOVE_SUCCESSUID},
{DCM_GROUPCOMMAND, DCM_CMDFAILEDINSTANCEUIDLIST, DCM_UI, "", 1, 0, (void *) &response.failedUIDs, &response.conditionalFields, MSG_K_C_MOVE_FAILEDUID},
{DCM_GROUPCOMMAND, DCM_CMDWARNINGINSTANCEUIDLIST, DCM_UI, "", 1, 0, (void *) &response.warningUIDs, &response.conditionalFields, MSG_K_C_MOVE_WARNINGUID},
{DCM_GROUPCOMMAND, DCM_CMDREMAININGSUBOPERATIONS, DCM_US, "", 1, sizeof(response.remainingSubOperations), (void *) &response.remainingSubOperations, &response.conditionalFields, MSG_K_C_MOVE_REMAINING},
{DCM_GROUPCOMMAND, DCM_CMDCOMPLETEDSUBOPERATIONS, DCM_US, "", 1, sizeof(response.completedSubOperations), (void *) &response.completedSubOperations, &response.conditionalFields, MSG_K_C_MOVE_COMPLETED},
{DCM_GROUPCOMMAND, DCM_CMDFAILEDSUBOPERATIONS, DCM_US, "", 1, sizeof(response.failedSubOperations), (void *) &response.failedSubOperations, &response.conditionalFields, MSG_K_C_MOVE_FAILED},
{DCM_GROUPCOMMAND, DCM_CMDWARNINGSUBOPERATIONS, DCM_US, "", 1, sizeof(response.warningSubOperations), (void *) &response.warningSubOperations, &response.conditionalFields, MSG_K_C_MOVE_WARNING},
};
void *ctx;
int index;
unsigned long rtnLength;
CONDITION cond;
for (index = 0; index < (int) DIM_OF(elementList); index++) {
ctx = NULL;
cond = DCM_GetElementValue(object, &elementList[index], &rtnLength, &ctx);
if (cond != DCM_NORMAL) return COND_PushCondition(MSG_PARSEFAILED, MSG_Message(MSG_PARSEFAILED));
}
response.type = MSG_K_C_MOVE_RESP;
for (index = 0; index < (int) DIM_OF(conditionalList); index++) {
cond = DCM_NORMAL;
e = conditionalList[index].e;
if (e.length == 0) {
cond = DCM_GetElementSize(object, DCM_MAKETAG(e.group, e.element), &rtnLength);
if (cond == DCM_NORMAL) {
e.length = rtnLength;
e.d.string = malloc(rtnLength + 1);
if (e.d.string == NULL) return 0; /* repair */
*conditionalList[index].e.d.stringArray = e.d.string;
}else{
(void) COND_PopCondition(FALSE);
}
}
if (cond == DCM_NORMAL) {
ctx = NULL;
cond = DCM_GetElementValue(object, &e, &rtnLength, &ctx);
if (cond == DCM_NORMAL) {
*conditionalList[index].flag |= conditionalList[index].flagBit;
e.d.string[rtnLength] = '\0';
}
}
}
*moveResponse = response;
return MSG_NORMAL;
}
main(int argc, char **argv)
{
CONDITION cond;
LST_HEAD *l,
*elementList;
DCM_ELEMENT_NODE *n,
*elementNode;
unsigned short group;
CTNBOOLEAN uidDictionary = FALSE;
while (--argc > 0 && (*++argv)[0] == '-') {
switch (*(argv[0] + 1)) {
case 'u':
uidDictionary = TRUE;
break;
default:
fprintf(stderr, "Unrecognized option: %s\n", *argv);
exit(1);
break;
}
}
THR_Init();
if (uidDictionary) {
UID_ScanDictionary(uidCallback, 0);
THR_Shutdown();
return 0;
}
l = LST_Create();
if (l == NULL) {
THR_Shutdown();
return 1;
}
elementList = LST_Create();
if (elementList == NULL) {
THR_Shutdown();
return 1;
}
cond = DCM_GroupDictionary(0xffff, &l, groupCallback);
if (cond != DCM_NORMAL) {
COND_DumpConditions();
THR_Shutdown();
exit(1);
}
n = LST_Dequeue(&l);
while (n != NULL) {
group = DCM_TAG_GROUP(n->e.tag);
printf("%04x %s\n", group, n->e.description);
cond = DCM_ElementDictionary(DCM_MAKETAG(group, 0xffff), &elementList,
elementCallback);
if (cond != DCM_NORMAL) {
COND_DumpConditions();
THR_Shutdown();
exit(1);
}
elementNode = LST_Dequeue(&elementList);
while (elementNode != NULL) {
printf(" %04x %04x %s %s\n",
DCM_TAG_GROUP(elementNode->e.tag),
DCM_TAG_ELEMENT(elementNode->e.tag),
translate(elementNode->e.representation),
elementNode->e.description);
free(elementNode);
elementNode = LST_Dequeue(&elementList);
}
free(n);
n = LST_Dequeue(&l);
}
THR_Shutdown();
return 0;
}
int main(int argc, char **argv)
{
char* attributeFile = 0;
bool verbose = false;
int seqGroup = 0;
int seqElement = 0;
int group = 0;
int element = 0;
char* language = ""; // Language of messages for evaluation
int level = 1; // Level 1 is errors only
while (--argc > 0 && (*++argv)[0] == '-') {
switch (*(argv[0] + 1)) {
case 'l':
argc--; argv++;
if (argc < 1)
usage();
level = atoi(*argv);
if (level > 2)
verbose = true;
break;
case 'L':
argc--;
argv++;
if (argc < 1)
usage();
language = *argv;
break;
case 's':
argc--;
argv++;
if (argc < 2)
usage();
if (::sscanf(*argv, "%x", &seqGroup) != 1) {
cerr << "Unable to scan group: " << *argv << endl;
usage();
}
argc--; argv++;
if (::sscanf(*argv, "%x", &seqElement) != 1) {
cerr << "Unable to scan element: " << *argv << endl;
usage();
}
break;
case 'v':
verbose = true;
level = 3;
break;
default:
break;
}
}
if (argc < 5)
usage();
if (::sscanf(argv[0], "%x", &group) != 1) {
cerr << "Unable to scan group: " << argv[0] << endl;
usage();
}
if (::sscanf(argv[1], "%x", &element) != 1) {
cerr << "Unable to scan group: " << argv[1] << endl;
usage();
}
DCM_TAG tag = DCM_MAKETAG(group, element);
DCM_TAG seqTag = DCM_MAKETAG(seqGroup, seqElement);
MString maskName(argv[2]);
MStringVector testFiles;
fillFileVector(testFiles, argv[3]);
MStringVector stdFiles;
fillFileVector(stdFiles, argv[4]);
if (stdFiles.size() != testFiles.size()) {
cout << "ERR: The number of responses in the test directory (" << argv[3] << ")" << endl
<< "ERR: does not match responses in the std directory (" << argv[4] << ")" << endl;
cout << "ERR: The counts are: " << testFiles.size() << " and "
<< stdFiles.size() << endl;
return 1;
}
int rtnStatus = 0;
int evaluationCount = stdFiles.size();
int failureCount = 0;
MStringMap testMap;
MStringMap stdMap;
fillMap(testMap, testFiles, seqTag, tag);
fillMap(stdMap, stdFiles, seqTag, tag);
MStringMap::iterator it = stdMap.begin();
for (it; it != stdMap.end(); it++) {
MString key = (*it).first;
MString stdFile = (*it).second;
MString tstFile = testMap[key];
if (verbose)
cout << key << " " << tstFile << " " << stdFile << endl;
int testStatus = evaluate(tstFile, stdFile, maskName, verbose, level, language);
if (testStatus != 0) {
cout << "ERR: C-Find resp evaluate failed for: " << tstFile << endl;
rtnStatus = 1;
failureCount++;
}
}
return rtnStatus;
}
int
evaluate(const MString& tstFile, const MString& stdFile,
const MString& maskName, bool verbose, int logLevel,
const MString& language)
{
char buf[1024];
maskName.safeExport(buf, sizeof(buf));
ifstream f(buf);
if (!f) {
cout << "ERR: Unable to open mask file: " << maskName << endl;
::exit(1);
}
MDICOMWrapper tstWrapper(tstFile);
MDICOMWrapper stdWrapper(stdFile);
MDICOMElementEval eval;
int rtnValue = 0;
while (f.getline(buf, sizeof(buf))) {
if ((buf[0] == '#' || buf[0] == '\n' || buf[0] == '\0'))
continue;
int gggg = 0, eeee = 0;
int seqGGGG = 0, seqEEEE = 0;
char c = ' ';
if (::sscanf(buf, "%x %x %x %x %c", &seqGGGG, &seqEEEE, &gggg, &eeee, &c) != 5) {
seqGGGG = seqEEEE = 0;
if (::sscanf(buf, "%x %x %c", &gggg, &eeee, &c) != 3) {
cout << "ERR: Mask file lines should be <gggg eeee c>: " << buf << endl;
cout << "ERR: or <gggg eeee gggg eeee c>" << buf << endl;
::exit(1);
}
}
DCM_TAG seqTag = DCM_MAKETAG(seqGGGG, seqEEEE);
DCM_TAG tag = DCM_MAKETAG(gggg, eeee);
MString tstString;
MString stdString;
bool attributePresent = false;
DCM_ELEMENT e;
::memset(&e, 0, sizeof(e));
e.tag = tag;
::DCM_LookupElement(&e);
::COND_PopCondition(TRUE);
if (seqGGGG == 0x0000) {
if (tstWrapper.attributePresent(tag))
attributePresent = true;
tstString = tstWrapper.getString(tag);
stdString = stdWrapper.getString(tag);
} else {
tstString = tstWrapper.getString(seqTag, tag);
stdString = stdWrapper.getString(seqTag, tag);
}
if (logLevel >= 3) {
if (e.representation == DCM_PN) {
cout << "CTX: " << buf << ":" << tstString << endl;
cout << "CTX: " << buf << ":" << stdString << endl;
} else {
cout << "CTX: " << buf << ":" << tstString << ":" << stdString << endl;
}
}
switch (c) {
case '=':
if (seqGGGG == 0x0000) {
int tmp = 0;
tmp = eval.evalElement(logLevel, tstWrapper, stdWrapper, tag, language);
if (tmp != 0) {
rtnValue = 1;
}
} else {
if (tstString != stdString) {
cout << "ERR: C-Find response failed for an attribute: " << buf << endl;
cout << "ERR: Your value: " << tstString << endl;
cout << "ERR: Expected v: " << stdString << endl;
rtnValue = 1;
}
}
break;
case 'O':
if (tstString.size() == 0) {
cout << "WARN: C-Find response examined for optional attribute: " << buf << endl;
cout << "WARN: Your response did not contain the value or it was 0-length" << endl;
cout << "WARN: This is merely an informative message." << endl;
}
break;
case 'P':
if (tstString.size() == 0) {
cout << "ERR: C-Find response expected to find a value for: " << buf << endl;
cout << "ERR: Your response did not contain the value or it was 0-length" << endl;
rtnValue = 1;
}
break;
case 'Z': // Test for present, but attribute can be zero length
if (! attributePresent) {
cout << "ERR: C-Find response expected to find a value for: " << buf << endl;
cout << "ERR: Your response did not contain the value" << endl;
rtnValue = 1;
}
break;
default:
break;
}
}
return rtnValue;
}
