/*
*
* ProLinga-Run
*
* Copyright (C) 2002-2008 Xobas Software.
* All rights reserved.
*
* This file is part of ProLinga-Run.
*
* ProLinga-Run is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ProLinga-Run is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ProLinga-Run. If not, see .
*
* More information is available at the following addresses:
*
* Website : http://www.prolinga.org
*
* Email : prolinga-list@prolinga.org
*
*
*/
#include "RunCommon.h"
#include
#include
#include
#include "RepositoryCommand.hpp"
#include "DataRef.hpp"
#include "Main.hpp"
//typedef GList *GListPtr;
extern DataDictionaryPtr dicPtr;
extern ConstantPtr consPtr;
extern DataModelPtr dmPtr;
extern VariablePtr varPtr;
extern VariableGroupPtr vgrpPtr;
extern TablePtr tablePtr;
extern TextDocumentPtr textPtr;
extern XmlDocumentPtr xmlPtr;
extern PickListPtr pickPtr;
//extern ScreenStackPtr dialogStackPtr;
extern BiAppnPtr biAppnPtr;
void FormatValue(const char *valueIn, const int editCode, const int decimalPlaces, const int maxLength, char *valueOut)
{
double tmpDbl;
char formatString[255];
//int width;
tmpDbl = strtod(valueIn, NULL);
if ((editCode == XB_DT_UNSIGNED_DECIMAL) && (tmpDbl < 0))
tmpDbl = tmpDbl * -1;
//if (padCharacter == '0')
// sprintf(formatString, "%%0%d.%df", maxLength, decimalPlaces);
//else
// sprintf(formatString, "%%%d.%df", maxLength, decimalPlaces);
//width = strlen(valueIn);
sprintf(formatString, "%%%d.%df", maxLength, decimalPlaces);
sprintf(valueOut,formatString, tmpDbl);
}
int NumberDaysInMonth(const int month, const int year)
{
switch (month)
{
case 1: return 31;
case 2: return (year % 4 == 0 ? (year % 400 == 0 ? 28 : 29) : 28);
case 3: return 31;
case 4: return 30;
case 5: return 31;
case 6: return 30;
case 7: return 31;
case 8: return 31;
case 9: return 30;
case 10: return 31;
case 11: return 30;
case 12: return 31;
default: return 0;
}
}
bool CheckIsValidDate(char* date)
{
char yearStr[5], monthStr[3], dayStr[3];
int year, month, day;
/* Date is in format CCYY-MM-DD */
/* Get year */
strncpy(yearStr, date, 4);
yearStr[4] = '\0';
year = atoi(yearStr);
/* Get month */
strncpy(monthStr, (date + 5), 2);
monthStr[2] = '\0';
month = atoi(monthStr);
/* Get day */
strncpy(dayStr, (date + 8), 2);
dayStr[2] = '\0';
day = atoi(dayStr);
/* Check year/month/day */
if (year < 1)
return false;
if (month < 1 || month > 12)
return false;
if (day < 1 || day > NumberDaysInMonth(month, year))
return false;
/* Return */
return true;
}
void FormatDate(char *valueIn, int dateFormatIn, char *valueOut, int dateFormatOut)
{
char yearStr[5], monthStr[3], dayStr[3];
/* If same format, no conversion needed */
if (dateFormatIn == dateFormatOut)
{
strcpy(valueOut, valueIn);
return;
}
/* Get Year */
if (dateFormatIn == XB_DT_FORMAT_1)
{
strncpy(yearStr, valueIn, 4);
yearStr[4] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_2)
{
strncpy(yearStr, valueIn+6, 4);
yearStr[4] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_3)
{
strncpy(yearStr, valueIn+6, 4);
yearStr[4] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_4)
{
strncpy(yearStr, valueIn, 4);
yearStr[4] = '\0';
}
/* Get Month */
if (dateFormatIn == XB_DT_FORMAT_1)
{
strncpy(monthStr, valueIn+5, 2);
monthStr[2] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_2)
{
strncpy(monthStr, valueIn+3, 2);
monthStr[2] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_3)
{
strncpy(monthStr, valueIn, 2);
monthStr[2] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_4)
{
strncpy(monthStr, valueIn+4, 2);
monthStr[2] = '\0';
}
/* Get Day */
if (dateFormatIn == XB_DT_FORMAT_1)
{
strncpy(dayStr, valueIn+8, 2);
dayStr[2] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_2)
{
strncpy(dayStr, valueIn, 2);
dayStr[2] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_3)
{
strncpy(dayStr, valueIn+3, 2);
dayStr[2] = '\0';
}
else if (dateFormatIn == XB_DT_FORMAT_4)
{
strncpy(dayStr, valueIn+6, 2);
dayStr[2] = '\0';
}
/* Output */
/* Init and Put Year */
if (dateFormatOut == XB_DT_FORMAT_1)
{
strcpy(valueOut, "CCYY-MM-DD");
strncpy(valueOut, yearStr, 4);
}
else if (dateFormatOut == XB_DT_FORMAT_2)
{
strcpy(valueOut, "DD/MM/CCYY");
strncpy(valueOut+6, yearStr, 4);
}
else if (dateFormatOut == XB_DT_FORMAT_3)
{
strcpy(valueOut, "MM/DD/CCYY");
strncpy(valueOut+6, yearStr, 4);
}
else if (dateFormatOut == XB_DT_FORMAT_4)
{
strcpy(valueOut, "CCYYMMDD");
strncpy(valueOut, yearStr, 4);
}
/* Put Month */
if (dateFormatOut == XB_DT_FORMAT_1)
strncpy(valueOut+5, monthStr, 2);
else if (dateFormatOut == XB_DT_FORMAT_2)
strncpy(valueOut+3, monthStr, 2);
else if (dateFormatOut == XB_DT_FORMAT_3)
strncpy(valueOut, monthStr, 2);
else if (dateFormatOut == XB_DT_FORMAT_4)
strncpy(valueOut+4, monthStr, 2);
/* Put Day */
if (dateFormatOut == XB_DT_FORMAT_1)
strncpy(valueOut+8, dayStr, 2);
else if (dateFormatOut == XB_DT_FORMAT_2)
strncpy(valueOut, dayStr, 2);
else if (dateFormatOut == XB_DT_FORMAT_3)
strncpy(valueOut+3, dayStr, 2);
else if (dateFormatOut == XB_DT_FORMAT_4)
strncpy(valueOut+6, dayStr, 2);
}
int getDateFormatDataRef(char *dataRef)
{
/* Determine which dataref */
if ((dataRef[0] == 'V') && (dataRef[1] == '-'))
return varPtr->getDateFormat(varPtr, dataRef+2);
else if ((dataRef[0] == 'C') && (dataRef[1] == '-'))
return consPtr->getDateFormat(consPtr, dataRef+2);
else if ((dataRef[0] == 'L') && (dataRef[1] == '-'))
return dicPtr->getDateFormat(dicPtr, dataRef+2);
else if ((dataRef[0] == 'G') && (dataRef[1] == '-'))
return vgrpPtr->getDateFormat(vgrpPtr, dataRef+2);
else if ((dataRef[0] == 'F') && (dataRef[1] == '-'))
return tablePtr->getDateFormat(tablePtr, dataRef+2);
else if (strcmp(dataRef, "DATE()") == 0)
return XB_DT_FORMAT_1;
// else if ((dataRef[0] == 'M') && (dataRef[1] == '-'))
// return dmPtr->getDateFormat(dmPtr, dataRef+2);
//
// else if ((dataRef[0] == 'P') && (dataRef[1] == '-'))
// return pickPtr->getDateFormat(pickPtr, dataRef+2);
/* Return in all other cases */
return -1;
}
void ValidateDateValue(const char *valueIn, int dateFormat, char *valueOut)
{
char date[11];
if (dateFormat == XB_DT_FORMAT_2)
{
/* DD/MM/CCYY */
/* Get year */
strncpy(date, valueIn+6, 4);
date[4] = '-';
/* Get month */
strncpy(date+5, valueIn+3, 2);
date[7] = '-';
/* Get day */
strncpy(date+8, valueIn, 2);
date[10] = '\0';
/* Check for valid date */
if (CheckIsValidDate(date) == true)
{
sprintf(valueOut,"%c%c/%c%c/%c%c%c%c", valueIn[0],
valueIn[1],
valueIn[3],
valueIn[4],
valueIn[6],
valueIn[7],
valueIn[8],
valueIn[9]);
}
else
{
sprintf(valueOut,"%c%c/%c%c/%c%c%c%c", XB_INVALID_DATE[8],
XB_INVALID_DATE[9],
XB_INVALID_DATE[5],
XB_INVALID_DATE[6],
XB_INVALID_DATE[0],
XB_INVALID_DATE[1],
XB_INVALID_DATE[2],
XB_INVALID_DATE[3]);
}
}
else if (dateFormat == XB_DT_FORMAT_3)
{
/* MM/DD/CCYY */
/* Get year */
strncpy(date, valueIn+6, 4);
date[4] = '-';
/* Get month */
strncpy(date+5, valueIn, 2);
date[7] = '-';
/* Get day */
strncpy(date+8, valueIn+3, 2);
date[10] = '\0';
/* Check for valid date */
if (CheckIsValidDate(date) == true)
{
sprintf(valueOut,"%c%c/%c%c/%c%c%c%c", valueIn[0],
valueIn[1],
valueIn[3],
valueIn[4],
valueIn[6],
valueIn[7],
valueIn[8],
valueIn[9]);
}
else
{
sprintf(valueOut,"%c%c/%c%c/%c%c%c%c", XB_INVALID_DATE[5],
XB_INVALID_DATE[6],
XB_INVALID_DATE[8],
XB_INVALID_DATE[9],
XB_INVALID_DATE[0],
XB_INVALID_DATE[1],
XB_INVALID_DATE[2],
XB_INVALID_DATE[3]);
}
}
else if (dateFormat == XB_DT_FORMAT_4)
{
/* CCYYMMDD */
/* Get year */
strncpy(date, valueIn, 4);
date[4] = '-';
/* Get month */
strncpy(date+5, valueIn+4, 2);
date[7] = '-';
/* Get day */
strncpy(date+8, valueIn+6, 2);
date[10] = '\0';
/* Check for valid date */
if (CheckIsValidDate(date) == true)
{
sprintf(valueOut,"%c%c%c%c%c%c%c%c", valueIn[0],
valueIn[1],
valueIn[2],
valueIn[3],
valueIn[4],
valueIn[5],
valueIn[6],
valueIn[7]);
}
else
{
sprintf(valueOut,"%c%c%c%c%c%c%c%c", XB_INVALID_DATE[0],
XB_INVALID_DATE[1],
XB_INVALID_DATE[2],
XB_INVALID_DATE[3],
XB_INVALID_DATE[5],
XB_INVALID_DATE[6],
XB_INVALID_DATE[8],
XB_INVALID_DATE[9]);
}
}
else
{
/* CCYY-MM-DD */
/* Get year */
strncpy(date, valueIn, 4);
date[4] = '-';
/* Get month */
strncpy(date+5, valueIn+5, 2);
date[7] = '-';
/* Get day */
strncpy(date+8, valueIn+8, 2);
date[10] = '\0';
/* Check for valid date */
if (CheckIsValidDate(date) == true)
{
sprintf(valueOut,"%c%c%c%c-%c%c-%c%c", valueIn[0],
valueIn[1],
valueIn[2],
valueIn[3],
valueIn[5],
valueIn[6],
valueIn[8],
valueIn[9]);
}
else
strcpy(valueOut, XB_INVALID_DATE);
}
}
void ResetBuffers(void)
{
/* List of Constants */
consPtr->deleteList(&consPtr);
/* List of DataModels */
dmPtr->deleteList(&dmPtr);
/* List of Variables */
varPtr->deleteList(&varPtr);
/* List of VariableGroups */
vgrpPtr->deleteList(&vgrpPtr);
/* List of Tables */
tablePtr->deleteList(&tablePtr);
/* List of Pick Lists */
pickPtr->deleteList(&pickPtr);
/* List of Text Documents */
textPtr->deleteList(&textPtr);
/* List of Xml Documents */
xmlPtr->deleteList(&xmlPtr);
/* Stack of dialog pointers */
// dialogStackPtr->deleteList(&dialogStackPtr);
}
char *getContentsTextDocument(const char *name, char *retValue)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxRes;
xmlXPathObjectPtr resRes;
/* Check Repository */
// docRes = RC_Get(biAppnPtr->getAppn(), "TextDocument", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "TextDocument", name) != 0)
return NULL;
/* Init XPath */
//xmlXPathInit();
/* Create XPath environment */
ctxRes = xmlXPathNewContext(docRes);
/* Value */
resRes = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/TextDocument/TextContents", ctxRes);
strcpy(retValue, (char *)xmlXPathCastToString(resRes));
/* Return */
return retValue;
}
DataDictionary::DataDictionary()
{
strcpy(dicName,"");
seqNo = 0;
maxLength = 0;
editCode = 0;
dateFormat = 0;
decimalPlaces = 0;
padCharacter = ' ';
// dicValue = NULL;
// dicValue = new char[maxLength];
dicValue = new char[2];
dicValue[0] = '\0';
nextPtr = NULL;
}
DataDictionary::~DataDictionary()
{
delete dicValue;
}
DataDictionary *DataDictionary::createList()
{
return new DataDictionary;
}
void DataDictionary::clearList(DataDictionary **dicPtr)
{
DataDictionary *curPtr;
curPtr = *dicPtr;
while (curPtr != NULL)
{
//printf("DD %s\n", curPtr->dicName);
//delete curPtr->dicValue;
//curPtr->dicValue = new char[1];
curPtr->dicValue[0] = '\0';
curPtr = curPtr->nextPtr;
}
}
void DataDictionary::deleteList(DataDictionary **dicPtr)
{
DataDictionary *curPtr, *nextPtr;
curPtr = *dicPtr;
*dicPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
//printf("hellodel2 %s\n",curPtr->dicName );
delete curPtr;
curPtr = nextPtr;
}
}
char *DataDictionary::getNameSeqNo(DataDictionary **dicPtr, const int sequence)
{
DataDictionary *curPtr;
/* Check if variable exist in memory */
curPtr = *dicPtr;
while (curPtr != NULL)
{
if (curPtr->seqNo == sequence)
return curPtr->dicName;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *DataDictionary::getValueSeqNo(DataDictionary **dicPtr, const int sequence)
{
DataDictionary *curPtr;
/* Check if variable exist in memory */
curPtr = *dicPtr;
while (curPtr != NULL)
{
if (curPtr->seqNo == sequence)
return curPtr->dicValue;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *DataDictionary::getValue(DataDictionary **dicPtr, const char *name)
{
DataDictionary *curPtr, *prevPtr, *newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *string, *value;
/* Check if variable exist in memory */
curPtr = *dicPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dicName, name) == 0)
return curPtr->dicValue;
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "DataDictionary", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "DataDictionary", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new DataDictionary;
strcpy(newPtr->dicName, name);
/* Max Length */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/MaximumLength", ctxt);
newPtr->maxLength = (int)xmlXPathCastToNumber(res);
/* Edit Code */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DataType", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "UnsignedDecimal") == 0)
newPtr->editCode = XB_DT_UNSIGNED_DECIMAL;
else if (strcmp(string, "SignedDecimal") == 0)
newPtr->editCode = XB_DT_SIGNED_DECIMAL;
else if (strcmp(string, "Boolean") == 0)
newPtr->editCode = XB_DT_BOOLEAN;
else if (strcmp(string, "Date") == 0)
{
newPtr->editCode = XB_DT_DATE;
/* Date Format */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DateFormat", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "DD/MM/CCYY") == 0)
newPtr->dateFormat = XB_DT_FORMAT_2;
else if (strcmp(string, "MM/DD/CCYY") == 0)
newPtr->dateFormat = XB_DT_FORMAT_3;
else if (strcmp(string, "CCYYMMDD") == 0)
newPtr->dateFormat = XB_DT_FORMAT_4;
else
newPtr->dateFormat = XB_DT_FORMAT_1;
}
else
newPtr->editCode = XB_DT_STRING;
/* Decimal Places */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DecimalPlaces", ctxt);
newPtr->decimalPlaces = (int)xmlXPathCastToNumber(res);
/* Justification */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/Justification", ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->justification = string[0];
/* Pad Character */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/PadCharacter", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strlen(string) == 1)
newPtr->padCharacter = string[0];
else
newPtr->padCharacter = ' ';
/* Value */
//res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/InitialValue", ctxt);
//value = (char *)xmlXPathCastToString(res);
value = "";
/* New Value (store all in char) */
newPtr->dicValue = new char[(newPtr->maxLength + 1)];
/* Format Value */
if (((newPtr->editCode == XB_DT_UNSIGNED_DECIMAL) || (newPtr->editCode = XB_DT_SIGNED_DECIMAL)) && (newPtr->decimalPlaces > 0))
FormatValue(value, newPtr->editCode, newPtr->decimalPlaces, newPtr->maxLength, newPtr->dicValue);
else if (newPtr->editCode == XB_DT_DATE)
ValidateDateValue(value, newPtr->dateFormat, newPtr->dicValue);
else
strcpy(newPtr->dicValue, value);
/* Next ptr null */
newPtr->nextPtr = NULL;
if (prevPtr == NULL)
*dicPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->dicValue;
}
char *DataDictionary::getValueData(DataDictionary **dicPtr, const char *name, int &retLength, char &retPadChar, char &retJustification)
{
DataDictionary *curPtr, *prevPtr, *newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *string, *value;
int length;
/* Check if variable exist in memory */
curPtr = *dicPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dicName, name) == 0)
{
retLength = curPtr->maxLength;
retPadChar = curPtr->padCharacter;
retJustification = curPtr->justification;
return curPtr->dicValue;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "DataDictionary", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "DataDictionary", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new DataDictionary;
strcpy(newPtr->dicName, name);
/* Max Length */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/MaximumLength", ctxt);
newPtr->maxLength = (int)xmlXPathCastToNumber(res);
/* Edit Code */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DataType", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "UnsignedDecimal") == 0)
newPtr->editCode = XB_DT_UNSIGNED_DECIMAL;
else if (strcmp(string, "SignedDecimal") == 0)
newPtr->editCode = XB_DT_SIGNED_DECIMAL;
else if (strcmp(string, "Boolean") == 0)
newPtr->editCode = XB_DT_BOOLEAN;
else if (strcmp(string, "Date") == 0)
{
newPtr->editCode = XB_DT_DATE;
/* Date Format */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DateFormat", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "DD/MM/CCYY") == 0)
newPtr->dateFormat = XB_DT_FORMAT_2;
else if (strcmp(string, "MM/DD/CCYY") == 0)
newPtr->dateFormat = XB_DT_FORMAT_3;
else if (strcmp(string, "CCYYMMDD") == 0)
newPtr->dateFormat = XB_DT_FORMAT_4;
else
newPtr->dateFormat = XB_DT_FORMAT_1;
}
else
newPtr->editCode = XB_DT_STRING;
/* Decimal Places */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DecimalPlaces", ctxt);
newPtr->decimalPlaces = (int)xmlXPathCastToNumber(res);
/* Justification */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/Justification", ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->justification = string[0];
/* Pad Character */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/PadCharacter", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strlen(string) == 1)
newPtr->padCharacter = string[0];
else
newPtr->padCharacter = ' ';
/* Value */
//res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/InitialValue", ctxt);
//value = (char *)xmlXPathCastToString(res);
value = "";
/* New Value (store all in char) */
newPtr->dicValue = new char[(newPtr->maxLength + 1)];
/* Format Value */
if (((newPtr->editCode == XB_DT_UNSIGNED_DECIMAL) || (newPtr->editCode = XB_DT_SIGNED_DECIMAL)) && (newPtr->decimalPlaces > 0))
FormatValue(value, newPtr->editCode, newPtr->decimalPlaces, newPtr->maxLength, newPtr->dicValue);
else if (newPtr->editCode == XB_DT_DATE)
ValidateDateValue(value, newPtr->dateFormat, newPtr->dicValue);
else
{
length = strlen(value);
if (length <= newPtr->maxLength)
strcpy(newPtr->dicValue, value);
else
{
strncpy(newPtr->dicValue, value, newPtr->maxLength);
newPtr->dicValue[newPtr->maxLength] = '\0';
}
}
/* Next ptr null */
newPtr->nextPtr = NULL;
if (prevPtr == NULL)
*dicPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
retLength = newPtr->maxLength;
retPadChar = newPtr->padCharacter;
retJustification = newPtr->justification;
return newPtr->dicValue;
}
int DataDictionary::getDateFormat(DataDictionary *dicPtr, const char *name)
{
DataDictionary *curPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *string;
int retValue = 0;
/* Check if variable exist in memory */
curPtr = dicPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dicName, name) == 0)
{
if (curPtr->editCode == XB_DT_DATE)
return curPtr->dateFormat;
else
return -1;
}
curPtr = curPtr->nextPtr;
}
/* Check Repository */
if (repGet(&docRes, biAppnPtr->getAppn(), "DataDictionary", name) != 0)
return -1;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Get Edit Code */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DataType", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "Date") == 0)
{
/* Date Format */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DateFormat", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "DD/MM/CCYY") == 0)
retValue = XB_DT_FORMAT_2;
else if (strcmp(string, "MM/DD/CCYY") == 0)
retValue = XB_DT_FORMAT_3;
else if (strcmp(string, "CCYYMMDD") == 0)
retValue = XB_DT_FORMAT_4;
else
retValue = XB_DT_FORMAT_1;
/* Cleanup */
if (docRes != NULL)
xmlFreeDoc(docRes);
/* Return */
return retValue;
}
else
{
/* Cleanup */
if (docRes != NULL)
xmlFreeDoc(docRes);
/* Non date field */
return -1;
}
/* Cleanup */
if (docRes != NULL)
xmlFreeDoc(docRes);
/* Return if all fails */
return -1;
}
int DataDictionary::getDateFormatSeqNo(DataDictionary *dicPtr, const int sequence)
{
DataDictionary *curPtr;
/* Check if variable exist in memory */
curPtr = dicPtr;
while (curPtr != NULL)
{
if (curPtr->seqNo == sequence)
{
if (curPtr->editCode == XB_DT_DATE)
return curPtr->dateFormat;
else
return -1;
}
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
void DataDictionary::putValue(DataDictionary **dicPtr, const char *name, const int sequence, const char *value)
{
DataDictionary *curPtr, *prevPtr, *newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *string;
int length;
//printf("TOC %s \n", name);
/* Check if local variable exist in memlist */
curPtr = *dicPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dicName, name) == 0)
{
/* Format Value */
if (((curPtr->editCode == XB_DT_UNSIGNED_DECIMAL) || \
(curPtr->editCode == XB_DT_SIGNED_DECIMAL)) && \
(curPtr->decimalPlaces > 0))
{
FormatValue(value, curPtr->editCode, curPtr->decimalPlaces, curPtr->maxLength, curPtr->dicValue);
return;
}
else if (curPtr->editCode == XB_DT_DATE)
ValidateDateValue(value, curPtr->dateFormat, curPtr->dicValue);
else
{
strcpy(curPtr->dicValue, value);
return;
}
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* If not then get DataDictionary */
// docRes = RC_Get(biAppnPtr->getAppn(), "DataDictionary", name);
/* If DD not exist, abort update attempt and return */
if (repGet(&docRes, biAppnPtr->getAppn(), "DataDictionary", name) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new DataDictionary;
strcpy(newPtr->dicName, name);
/* Sequence No */
newPtr->seqNo = sequence;
/* Max Length */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/MaximumLength", ctxt);
newPtr->maxLength = (int)xmlXPathCastToNumber(res);
/* Edit Code */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DataType", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "UnsignedDecimal") == 0)
newPtr->editCode = XB_DT_UNSIGNED_DECIMAL;
else if (strcmp(string, "SignedDecimal") == 0)
newPtr->editCode = XB_DT_SIGNED_DECIMAL;
else if (strcmp(string, "Date") == 0)
{
newPtr->editCode = XB_DT_DATE;
/* Date Format */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DateFormat", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "DD/MM/CCYY") == 0)
newPtr->dateFormat = XB_DT_FORMAT_2;
else if (strcmp(string, "MM/DD/CCYY") == 0)
newPtr->dateFormat = XB_DT_FORMAT_3;
else if (strcmp(string, "CCYYMMDD") == 0)
newPtr->dateFormat = XB_DT_FORMAT_4;
else
newPtr->dateFormat = XB_DT_FORMAT_1;
}
else if (strcmp(string, "Boolean") == 0)
newPtr->editCode = XB_DT_BOOLEAN;
else
newPtr->editCode = XB_DT_STRING;
/* Decimal Places */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/DecimalPlaces", ctxt);
newPtr->decimalPlaces = (int)xmlXPathCastToNumber(res);
/* Justification */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/Justification", ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->justification = string[0];
/* Pad Character */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/DataDictionary/PadCharacter", ctxt);
string = (char *)xmlXPathCastToString(res);
if (strlen(string) == 1)
newPtr->padCharacter = string[0];
else
newPtr->padCharacter = ' ';
/* New Value (store all in char) */
newPtr->dicValue = new char[(newPtr->maxLength + 1)];
/* Format Value */
if (((newPtr->editCode == XB_DT_UNSIGNED_DECIMAL) || (newPtr->editCode == XB_DT_SIGNED_DECIMAL)) && (newPtr->decimalPlaces > 0))
FormatValue(value, newPtr->editCode, newPtr->decimalPlaces, newPtr->maxLength, newPtr->dicValue);
else if (newPtr->editCode == XB_DT_DATE)
ValidateDateValue(value, newPtr->dateFormat, newPtr->dicValue);
else
{
length = strlen(value);
if (length <= newPtr->maxLength)
strcpy(newPtr->dicValue, value);
else
{
strncpy(newPtr->dicValue, value, newPtr->maxLength);
newPtr->dicValue[newPtr->maxLength] = '\0';
}
}
/* Next ptr null */
newPtr->nextPtr = NULL;
if (prevPtr == NULL)
{
/* First Record */
*dicPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
}
void DataDictionary::putValueSeqNo(DataDictionary **dicPtr, const int sequence, const char *value)
{
DataDictionary *curPtr;
/* Check if local variable exist in memlist */
curPtr = *dicPtr;
while (curPtr != NULL)
{
if (curPtr->seqNo == sequence)
{
/* Format Value */
if (((curPtr->editCode == XB_DT_UNSIGNED_DECIMAL) || \
(curPtr->editCode == XB_DT_SIGNED_DECIMAL)) && \
(curPtr->decimalPlaces > 0))
{
FormatValue(value, curPtr->editCode, curPtr->decimalPlaces, curPtr->maxLength, curPtr->dicValue);
return;
}
else if (curPtr->editCode == XB_DT_DATE)
ValidateDateValue(value, curPtr->dateFormat, curPtr->dicValue);
else
{
strcpy(curPtr->dicValue, value);
return;
}
}
curPtr = curPtr->nextPtr;
}
}
void DataDictionary::printList(DataDictionary *dicPtr) const
{
DataDictionary *curPtr;
curPtr = dicPtr;
while (curPtr != NULL)
{
printf("Data Dictionary Name %s\n", curPtr->dicName);
printf("Data Dictionary Value %s\n", curPtr->dicValue);
printf("Data Dictionary Sequence %d\n", curPtr->seqNo);
curPtr = curPtr->nextPtr;
}
}
LocalDataDictionary::LocalDataDictionary()
{
startPtr = NULL;
nextPtr = NULL;
}
void LocalDataDictionary::push(LocalDataDictionary **topPtr, DataDictionary *dicPtr)
{
LocalDataDictionary *newPtr;
newPtr = new LocalDataDictionary;
newPtr->startPtr = dicPtr;
newPtr->nextPtr = *topPtr;
*topPtr = newPtr;
}
void LocalDataDictionary::pop(LocalDataDictionary **topPtr)
{
LocalDataDictionary *tmpPtr;
tmpPtr = *topPtr;
*topPtr = (*topPtr)->nextPtr;
delete tmpPtr;
}
DataDictionary *LocalDataDictionary::getValue(LocalDataDictionary *topPtr)
{
if (topPtr == NULL)
return NULL;
else
return topPtr->startPtr;
}
void LocalDataDictionary::deleteStack(LocalDataDictionary **topPtr)
{
LocalDataDictionary *tmpPtr;
tmpPtr = *topPtr;
while (*topPtr != NULL)
{
*topPtr = (*topPtr)->nextPtr;
delete tmpPtr;
}
}
Variable::Variable()
{
strcpy(varName, "");
strcpy(dicName, "");
startPtr = NULL;
nextPtr = NULL;
}
Variable::~Variable()
{
/* Delete DataDictionary List */
// if (startPtr != NULL)
// startPtr->deleteList(&startPtr);
}
char *Variable::getValue(VariablePtr *varPtr, const char *name)
{
VariablePtr curPtr, prevPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *initialValue;
/* Check if variable exist in memory */
curPtr = *varPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->varName, name) == 0)
return curPtr->startPtr->getValue(&curPtr->startPtr, curPtr->dicName);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "Variable", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "Variable", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Variable;
strcpy(newPtr->varName, name);
/* Data Dictionary Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Variable/DataDictionaryName", ctxt);
strcpy(newPtr->dicName, (char *)xmlXPathCastToString(res));
/* Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Variable/InitialValue", ctxt);
initialValue = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, newPtr->dicName, 1, initialValue);
/* Next ptr null */
newPtr->nextPtr = NULL;
if (prevPtr == NULL)
{
/* First Record */
*varPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValue(&newPtr->startPtr, newPtr->dicName);
}
char *Variable::getValueData(VariablePtr *varPtr, const char *name, int &retLength, char &retPadChar, char &retJustification)
{
VariablePtr curPtr, prevPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *initialValue;
/* Check if variable exist in memory */
curPtr = *varPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->varName, name) == 0)
return curPtr->startPtr->getValueData(&curPtr->startPtr, curPtr->dicName, retLength, retPadChar, retJustification);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "Variable", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "Variable", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Variable;
strcpy(newPtr->varName, name);
/* Data Dictionary Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Variable/DataDictionaryName", ctxt);
strcpy(newPtr->dicName, (char *)xmlXPathCastToString(res));
/* Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Variable/InitialValue", ctxt);
initialValue = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, newPtr->dicName, 1, initialValue);
/* Next ptr null */
newPtr->nextPtr = NULL;
if (prevPtr == NULL)
{
/* First Record */
*varPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValueData(&newPtr->startPtr, newPtr->dicName, retLength, retPadChar, retJustification);
}
int Variable::getDateFormat(Variable *varPtr, const char *name)
{
Variable *curPtr;
/* Check if variable exist in memory */
curPtr = varPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->varName, name) == 0)
return curPtr->startPtr->getDateFormat(curPtr->startPtr, curPtr->dicName);
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
void Variable::putValue(VariablePtr *varPtr, const char *name, const char *value)
{
VariablePtr curPtr, prevPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
/* Check if variable exists in memlist */
curPtr = *varPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if(strcmp(curPtr->varName, name) == 0)
{
curPtr->startPtr->putValue(&curPtr->startPtr, curPtr->dicName, 1, value);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* If not then get Variable */
//docRes = RC_Get(biAppnPtr->getAppn(), "Variable", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "Variable", name) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Variable;
strcpy(newPtr->varName, name);
/* Data Dictionary Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Variable/DataDictionaryName", ctxt);
strcpy(newPtr->dicName, (char *)xmlXPathCastToString(res));
newPtr->startPtr->putValue(&newPtr->startPtr, newPtr->dicName, 1, value);
/* Next ptr null */
newPtr->nextPtr = NULL;
if (prevPtr == NULL)
{
/* First Record */
*varPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
}
void Variable::deleteOne(Variable **varPtr, const char *name)
{
Variable *prevPtr, *curPtr, *nextPtr;
prevPtr = NULL;
curPtr = *varPtr;
nextPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
if (strcmp(curPtr->varName, name) == 0)
{
/* Unlink Variable */
if (prevPtr == NULL)
*varPtr = nextPtr;
else
prevPtr->nextPtr = nextPtr;
/* Delete DataDictionary */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete Variable */
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = nextPtr;
}
}
void Variable::deleteList(VariablePtr *varPtr)
{
VariablePtr tmpPtr;
while (*varPtr != NULL)
{
tmpPtr = *varPtr;
*varPtr = (*varPtr)->nextPtr;
tmpPtr->startPtr->deleteList(&tmpPtr->startPtr);
delete tmpPtr;
}
}
void Variable::printList(VariablePtr varPtr) const
{
VariablePtr curPtr;
curPtr = varPtr;
while (curPtr != NULL)
{
printf("Variable Name %s\n", curPtr->varName);
curPtr->startPtr->printList(curPtr->startPtr);
curPtr = curPtr->nextPtr;
}
}
VariableGroup::VariableGroup()
{
strcpy(vgrpName, "");
numEntries = 0;
startPtr = NULL;
nextPtr = NULL;
}
VariableGroup::~VariableGroup()
{
// Delete DataDictionary List?
}
char *VariableGroup::getValue(VariableGroup **vgrpPtr, const char *name)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
VariableGroupPtr curPtr, prevPtr, newPtr;
char *variableGroupName, dataDictionaryName[32], *initialValue;
char dataName[64], stm[255];
int len1, len2;
short i,insHits;
/* Get Variable Group Name */
variableGroupName = (strstr(name, ".")+1);
/* Get Data (Dictionary) Name */
len1 = strlen(name);
len2 = strlen(variableGroupName);
strcpy(dataName, name);
dataName[(strlen(name)-strlen(variableGroupName)-1)] = '\0';
/* Find VG name*/
curPtr = *vgrpPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, variableGroupName) == 0)
return curPtr->startPtr->getValue(&curPtr->startPtr, dataName);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new variable group */
/* Get VariableGroup */
//docRes = RC_Get(biAppnPtr->getAppn(), "VariableGroup", variableGroupName);
if (repGet(&docRes, biAppnPtr->getAppn(), "VariableGroup", variableGroupName) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new VariableGroup;
strcpy(newPtr->vgrpName, variableGroupName);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
strcpy(dataDictionaryName,(char *)xmlXPathCastToString(res));
sprintf(stm, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/InitialValue", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
initialValue = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, dataDictionaryName, i, initialValue);
}
if (prevPtr == NULL)
{
/* First Record */
*vgrpPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValue(&newPtr->startPtr, dataName);
}
char *VariableGroup::getValueData(VariableGroup **vgrpPtr, const char *name, int &retLength, char &retPadChar, char &retJustification)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
VariableGroupPtr curPtr, prevPtr, newPtr;
char *variableGroupName, dataDictionaryName[32], *initialValue;
char dataName[64], stm[255];
int len1, len2;
short i,insHits;
/* Get Variable Group Name */
variableGroupName = (strstr(name, ".")+1);
/* Get Data (Dictionary) Name */
len1 = strlen(name);
len2 = strlen(variableGroupName);
strcpy(dataName, name);
dataName[(strlen(name)-strlen(variableGroupName)-1)] = '\0';
/* Find VG name*/
curPtr = *vgrpPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, variableGroupName) == 0)
return curPtr->startPtr->getValueData(&curPtr->startPtr, dataName, retLength, retPadChar, retJustification);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new variable group */
/* Get VariableGroup */
//docRes = RC_Get(biAppnPtr->getAppn(), "VariableGroup", variableGroupName);
if (repGet(&docRes, biAppnPtr->getAppn(), "VariableGroup", variableGroupName) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new VariableGroup;
strcpy(newPtr->vgrpName, variableGroupName);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
strcpy(dataDictionaryName,(char *)xmlXPathCastToString(res));
sprintf(stm, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/InitialValue", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
initialValue = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, dataDictionaryName, i, initialValue);
}
if (prevPtr == NULL)
{
/* First Record */
*vgrpPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValueData(&newPtr->startPtr, dataName, retLength, retPadChar, retJustification);
}
int VariableGroup::getDateFormat(VariableGroup *vgrpPtr, const char *name)
{
VariableGroupPtr curPtr;
char *variableGroupName;
char dataName[64];
int len1, len2;
/* Get Variable Group Name */
variableGroupName = (strstr(name, ".")+1);
/* Get Data (Dictionary) Name */
len1 = strlen(name);
len2 = strlen(variableGroupName);
strcpy(dataName, name);
dataName[(strlen(name)-strlen(variableGroupName)-1)] = '\0';
/* Find VG name*/
curPtr = vgrpPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, variableGroupName) == 0)
return curPtr->startPtr->getDateFormat(curPtr->startPtr, dataName);
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
int VariableGroup::getDateFormatSeqNo(VariableGroup *vgrpPtr, const char *vargroup, const int sequence)
{
VariableGroupPtr curPtr;
/* Find VG name*/
curPtr = vgrpPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, vargroup) == 0)
return curPtr->startPtr->getDateFormatSeqNo(curPtr->startPtr, sequence);
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
char *VariableGroup::getValueSeqNo(VariableGroup **vgrpPtr, const char *vargroup, const int sequence)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
VariableGroupPtr curPtr, prevPtr, newPtr;
int i, insHits;
char *initialValue, evalString[1024], dataDictionaryName[32];
/* Find VG name*/
curPtr = *vgrpPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, vargroup) == 0)
return curPtr->startPtr->getValueSeqNo(&curPtr->startPtr, sequence);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new variable group */
/* Get VariableGroup */
//docRes = RC_Get(biAppnPtr->getAppn(), "VariableGroup", vargroup);
if (repGet(&docRes, biAppnPtr->getAppn(), "VariableGroup", vargroup) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new VariableGroup;
strcpy(newPtr->vgrpName, vargroup);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry)", ctxt);
insHits = (int)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(evalString, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)evalString, ctxt);
strcpy(dataDictionaryName,(char *)xmlXPathCastToString(res));
sprintf(evalString, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/InitialValue", i);
res = xmlXPathEval((const xmlChar *)evalString, ctxt);
initialValue = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, dataDictionaryName, i, initialValue);
}
if (prevPtr == NULL)
{
/* First Record */
*vgrpPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValueSeqNo(&newPtr->startPtr, sequence);
}
int VariableGroup::getNumEntries(VariableGroup **vgrpPtr, const char *vargroup)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
VariableGroupPtr curPtr, prevPtr, newPtr;
char *initialValue, dataDictionaryName[32], evalString[255];
int i, insHits;
/* Find VG name*/
curPtr = *vgrpPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, vargroup) == 0)
return curPtr->numEntries;
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new variable group */
/* Get VariableGroup */
//docRes = RC_Get(biAppnPtr->getAppn(), "VariableGroup", vargroup);
if (repGet(&docRes, biAppnPtr->getAppn(), "VariableGroup", vargroup) != 0)
return 0;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new VariableGroup;
strcpy(newPtr->vgrpName, vargroup);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(evalString, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)evalString, ctxt);
strcpy(dataDictionaryName,(char *)xmlXPathCastToString(res));
sprintf(evalString, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/InitialValue", i);
res = xmlXPathEval((const xmlChar *)evalString, ctxt);
initialValue = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, dataDictionaryName, i, initialValue);
}
if (prevPtr == NULL)
{
/* First Record */
*vgrpPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->numEntries;
}
void VariableGroup::putValue(VariableGroupPtr *vgrpPtr, const char *name, const char *value)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
VariableGroupPtr curPtr, prevPtr, newPtr;
char *variableGroupName, *string;
char dataName[64], stm[255];
short i,insHits;
/* Get VariableGroup Name */
variableGroupName = (strstr(name, ".")+1);
/* Get Data(Dictionary) Name */
strcpy(dataName, name);
dataName[(strlen(name)-strlen(variableGroupName)-1)] = '\0';
/* Find VG name and change dictionary */
curPtr = *vgrpPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, variableGroupName) == 0)
{
curPtr->startPtr->putValue(&curPtr->startPtr, dataName, 0, value);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new variable group */
/* Get VariableGroup */
//docRes = RC_Get(biAppnPtr->getAppn(), "VariableGroup", variableGroupName);
if (repGet(&docRes, biAppnPtr->getAppn(), "VariableGroup", variableGroupName) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new VariableGroup;
strcpy(newPtr->vgrpName, variableGroupName);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/VariableGroup/OccurrencesVariableEntry/VariableEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(dataName, string) == 0)
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, value);
else
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*vgrpPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
}
void VariableGroup::putValueSeqNo(VariableGroup **vgrpPtr, const char *vargroup, const int sequence, const char *value)
{
VariableGroupPtr curPtr;
/* Find VG name*/
curPtr = *vgrpPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->vgrpName, vargroup) == 0)
curPtr->startPtr->putValueSeqNo(&curPtr->startPtr, sequence, value);
curPtr = curPtr->nextPtr;
}
}
void VariableGroup::deleteOne(VariableGroup **vgrpPtr, const char *name)
{
VariableGroup *prevPtr, *curPtr, *nextPtr;
prevPtr = NULL;
curPtr = *vgrpPtr;
nextPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
if (strcmp(curPtr->vgrpName, name) == 0)
{
/* Unlink VariableGroup */
if (prevPtr == NULL)
*vgrpPtr = nextPtr;
else
prevPtr->nextPtr = nextPtr;
/* Delete DataDictionary List */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete VariableGroup */
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = nextPtr;
}
}
void VariableGroup::deleteList(VariableGroup **vgrpPtr)
{
VariableGroup *curPtr, *nextPtr;
/* Init */
curPtr = *vgrpPtr;
*vgrpPtr = NULL;
nextPtr = NULL;
while (curPtr != NULL)
{
/* Look ahead */
nextPtr = curPtr->nextPtr;
/* Delete DataDictionary List */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete VariableGroup */
delete curPtr;
curPtr = nextPtr;
}
}
void VariableGroup::printList(VariableGroup *vgrpPtr) const
{
VariableGroup *curPtr;
curPtr = vgrpPtr;
while (curPtr != NULL)
{
printf("Variable Group Name %s\n", curPtr->vgrpName);
curPtr->startPtr->printList(curPtr->startPtr);
curPtr = curPtr->nextPtr;
}
}
Record::Record()
{
strcpy(recName, "");
numEntries = 0;
startPtr = NULL;
nextPtr = NULL;
}
Record::~Record()
{
//Delete Record List?
}
char *Record::getValue(Record **recordPtr, const char *name)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
RecordPtr curPtr, prevPtr, newPtr;
char *recordName, *string;
char dataName[64], stm[255];
short i,insHits;
/* Get Record Name */
recordName = (strstr(name, ".")+1);
/* Get Data (Dictionary) Name */
strcpy(dataName, name);
dataName[(strlen(name)-strlen(recordName)-1)] = '\0';
/* Find Record name */
curPtr = *recordPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, recordName) == 0)
return curPtr->startPtr->getValue(&curPtr->startPtr, dataName);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
/* Get Record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Record", recordName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Record", recordName) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Record;
strcpy(newPtr->recName, recordName);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*recordPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return "";
}
char *Record::getValueData(Record **recordPtr, const char *name, int &retLength, char &retPadChar, char &retJustification)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
RecordPtr curPtr, prevPtr, newPtr;
char *recordName, *string;
char dataName[64], stm[255];
short i,insHits;
/* Get Record Name */
recordName = (strstr(name, ".")+1);
/* Get Data (Dictionary) Name */
strcpy(dataName, name);
dataName[(strlen(name)-strlen(recordName)-1)] = '\0';
/* Find Record name */
curPtr = *recordPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, recordName) == 0)
return curPtr->startPtr->getValueData(&curPtr->startPtr, dataName, retLength, retPadChar, retJustification);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
/* Get Record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Record", recordName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Record", recordName) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Record;
strcpy(newPtr->recName, recordName);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*recordPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return "";
}
char *Record::getNameSeqNo(Record **recordPtr, const char *record, const int sequence)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
RecordPtr curPtr, prevPtr, newPtr;
char *string;
char stm[255];
short i,insHits;
/* Find Record name */
curPtr = *recordPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, record) == 0)
return curPtr->startPtr->getNameSeqNo(&curPtr->startPtr, sequence);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
/* Get Record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Record", record);
if (repGet(&docRes, biAppnPtr->getAppn(), "Record", record) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Record;
strcpy(newPtr->recName, record);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*recordPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return newPtr->startPtr->getNameSeqNo(&newPtr->startPtr, sequence);
}
char *Record::getValueSeqNo(Record **recordPtr, const char *record, const int sequence)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
RecordPtr curPtr, prevPtr, newPtr;
char *string;
char stm[255];
short i,insHits;
/* Find Record name */
curPtr = *recordPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, record) == 0)
return curPtr->startPtr->getValueSeqNo(&curPtr->startPtr, sequence);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
/* Get Record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Record", record);
if (repGet(&docRes, biAppnPtr->getAppn(), "Record", record) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Record;
strcpy(newPtr->recName, record);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*recordPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return newPtr->startPtr->getValueSeqNo(&newPtr->startPtr, sequence);
}
int Record::getNumEntries(Record **recordPtr, const char *record)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
RecordPtr curPtr, prevPtr, newPtr;
char *string;
char evalString[255];
short i,insHits;
/* Find Record name */
curPtr = *recordPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, record) == 0)
return curPtr->numEntries;
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
/* Get Record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Record", record);
if (repGet(&docRes, biAppnPtr->getAppn(), "Record", record) != 0)
return 0;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Record;
strcpy(newPtr->recName, record);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(evalString, "/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)evalString, ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*recordPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return newPtr->numEntries;
}
int Record::getDateFormat(Record *recordPtr, const char *name)
{
RecordPtr curPtr;
char *recordName;
char dataName[64];
/* Get Record Name */
recordName = (strstr(name, ".")+1);
/* Get Data (Dictionary) Name */
strcpy(dataName, name);
dataName[(strlen(name)-strlen(recordName)-1)] = '\0';
/* Find Record name */
curPtr = recordPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, recordName) == 0)
return curPtr->startPtr->getDateFormat(curPtr->startPtr, dataName);
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
int Record::getDateFormatSeqNo(Record *recordPtr, const char *record, const int sequence)
{
RecordPtr curPtr;
/* Find Record name */
curPtr = recordPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, record) == 0)
return curPtr->startPtr->getDateFormatSeqNo(curPtr->startPtr, sequence);
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
void Record::putValue(Record **recordPtr, const char *name, const char *value)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
RecordPtr curPtr, prevPtr, newPtr;
char *recordName, *string;
char dataName[255], stm[255];
short i, insHits;
/* Get Record Name */
recordName = (strstr(name, ".")+1);
/* Get Data(Dictionary) Name */
strcpy(dataName, name);
dataName[(strlen(name)-strlen(recordName)-1)] = '\0';
/* Find Record name and change dictionary */
curPtr = *recordPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, recordName) == 0)
{
curPtr->startPtr->putValue(&curPtr->startPtr, dataName, 0, value);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
/* Get Record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Record", recordName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Record", recordName) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Record;
strcpy(newPtr->recName, recordName);
/* Process Dictionaries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Number of entries */
newPtr->numEntries = (int)insHits;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/Record/OccurrencesDataDictionaryEntry/DataDictionaryEntry[%d]/DataDictionaryName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(dataName, string) == 0)
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, value);
else
newPtr->startPtr->putValue(&newPtr->startPtr, string, i, "");
}
if (prevPtr == NULL)
{
/* First Record */
*recordPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
}
void Record::putValueSeqNo(Record **recPtr, const char *record, const int sequence, const char *value)
{
RecordPtr curPtr;
/* Find Record name*/
curPtr = *recPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, record) == 0)
curPtr->startPtr->putValueSeqNo(&curPtr->startPtr, sequence, value);
curPtr = curPtr->nextPtr;
}
}
void Record::clearOne(Record **recPtr, const char *name)
{
Record *curPtr;
curPtr = *recPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->recName, name) == 0)
{
//printf("!!!!!!!!!!!!! RECORD %s en %s\n", curPtr->recName, name);
/* Clear DataDictionary List */
curPtr->startPtr->clearList(&curPtr->startPtr);
}
curPtr = curPtr->nextPtr;
}
}
void Record::deleteOne(Record **recPtr, const char *name)
{
Record *prevPtr, *curPtr, *nextPtr;
prevPtr = NULL;
curPtr = *recPtr;
nextPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
if (strcmp(curPtr->recName, name) == 0)
{
/* Unlink Record */
if (prevPtr == NULL)
*recPtr = nextPtr;
else
prevPtr->nextPtr = nextPtr;
/* Delete DataDictionary List */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete Record */
delete curPtr;
}
prevPtr = curPtr;
curPtr = nextPtr;
}
}
void Record::deleteList(Record **recPtr)
{
Record *curPtr, *nextPtr;
/* Init */
curPtr = *recPtr;
nextPtr = NULL;
*recPtr = NULL;
while (curPtr != NULL)
{
/* Look ahead */
nextPtr = curPtr->nextPtr;
/* Delete DataDictionary List */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete Record */
delete curPtr;
curPtr = nextPtr;
}
}
void Record::printList(Record *recordPtr) const
{
Record *curPtr;
curPtr = recordPtr;
while (curPtr != NULL)
{
printf("Record Name %s\n", curPtr->recName);
curPtr->startPtr->printList(curPtr->startPtr);
curPtr = curPtr->nextPtr;
}
}
Table::Table()
{
strcpy(tableName, "");
strcpy(externalName, "");
strcpy(dataSourceName, "");
startPtr = NULL;
nextPtr = NULL;
docTable = xmlNewDoc((const xmlChar *)"1.0");
docTable->children = xmlNewDocNode(docTable, NULL, (const xmlChar *)"ProLinga", NULL);
}
Table::~Table()
{
// Delete Table list?
xmlFreeDoc(docTable);
}
char *Table::getValue(Table **tablePtr, const char *name)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
TablePtr curPtr, prevPtr, newPtr;
char *string, *string2, *tableName = "", *recName = "", *dicName = "", *token, dicRec[255], stm[255];
char *defRecName, tmpName[1024];
short insHits, i = 1;
strcpy(tmpName, name);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if ( i == 1)
dicName = token;
if (i == 2)
tableName = token;
if (i == 3)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 3)
recName = "";
/* Find Table name and change record-->>dictionary */
curPtr = *tablePtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
if (strcmp(recName, "") == 0 )
strcat(dicRec, curPtr->defRecordName);
else
strcat(dicRec, recName);
return curPtr->startPtr->getValue(&curPtr->startPtr, dicRec);
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Table", tableName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Table", tableName) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Table;
strcpy(newPtr->tableName, tableName);
/* Get External Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/ExternalName", ctxt);
strcpy(newPtr->externalName, (char *)xmlXPathCastToString(res));
/* Get Data Source Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/DataSourceName", ctxt);
strcpy(newPtr->dataSourceName, (char *)xmlXPathCastToString(res));
/* Process Records */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Get Default Record Name */
for (i = 1; i <= insHits; i++)
{
/* Check if default record */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "True") != 0)
continue;
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
defRecName = (char *)xmlXPathCastToString(res);
strcpy(newPtr->defRecordName, defRecName);
break;
}
for (i = 1; i <= insHits; i++)
{
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
//printf("%s\n", string);
/* If default record set value */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string2 = (char *)xmlXPathCastToString(res);
//printf("%s\n", string2);
if (strcmp(recName, string) == 0)
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
strcat(dicRec, recName);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
else if ( (strcmp(recName, "") == 0) && (strcmp(string2, "Default")) )
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
strcat(dicRec, string);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
else
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
if (strcmp(recName, "") == 0 )
strcat(dicRec, curPtr->defRecordName);
else
strcat(dicRec, recName);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
}
if (prevPtr == NULL)
{
/* First Record */
*tablePtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return "";
}
char *Table::getValueData(Table **tablePtr, const char *name, int &retLength, char &retPadChar, char &retJustification)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
TablePtr curPtr, prevPtr, newPtr;
char *string, *string2, *tableName = "", *recName = "", *dicName = "", *token, dicRec[255], stm[255];
char *defRecName, tmpName[1024];
short insHits, i = 1;
strcpy(tmpName, name);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if ( i == 1)
dicName = token;
if (i == 2)
tableName = token;
if (i == 3)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 3)
recName = "";
/* Find Table name and change record-->>dictionary */
curPtr = *tablePtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
if (strcmp(recName, "") == 0 )
strcat(dicRec, curPtr->defRecordName);
else
strcat(dicRec, recName);
return curPtr->startPtr->getValueData(&curPtr->startPtr, dicRec, retLength, retPadChar, retJustification);
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Table", tableName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Table", tableName) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Table;
strcpy(newPtr->tableName, tableName);
/* Get External Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/ExternalName", ctxt);
strcpy(newPtr->externalName, (char *)xmlXPathCastToString(res));
/* Get Data Source Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/DataSourceName", ctxt);
strcpy(newPtr->dataSourceName, (char *)xmlXPathCastToString(res));
/* Process Records */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Get Default Record Name */
for (i = 1; i <= insHits; i++)
{
/* Check if default record */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "True") != 0)
continue;
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
defRecName = (char *)xmlXPathCastToString(res);
strcpy(newPtr->defRecordName, defRecName);
break;
}
for (i = 1; i <= insHits; i++)
{
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
//printf("%s\n", string);
/* If default record set value */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string2 = (char *)xmlXPathCastToString(res);
//printf("%s\n", string2);
if (strcmp(recName, string) == 0)
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
strcat(dicRec, recName);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
else if ( (strcmp(recName, "") == 0) && (strcmp(string2, "Default")) )
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
strcat(dicRec, string);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
else
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
if (strcmp(recName, "") == 0 )
strcat(dicRec, curPtr->defRecordName);
else
strcat(dicRec, recName);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
}
if (prevPtr == NULL)
{
/* First Record */
*tablePtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return "";
}
char *Table::getNameSeqNo(Table **tablePtr, const char *tabrec, const int sequence)
{
TablePtr curPtr;
char *tableName = "", *recName = "", *token;
char tmpName[1024];
short i = 1;
strcpy(tmpName, tabrec);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if (i == 1)
tableName = token;
if (i == 2)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 2)
recName = "";
/* Find Table name and get record-->>dictionary */
curPtr = *tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
if (strcmp(recName, "") == 0 )
return curPtr->startPtr->getNameSeqNo(&curPtr->startPtr, curPtr->defRecordName, sequence);
else
return curPtr->startPtr->getNameSeqNo(&curPtr->startPtr, recName, sequence);
}
curPtr = curPtr->nextPtr;
}
/* No default values possible, so point of creating at this stage */
/* RETURN */
return NULL;
}
char *Table::getValueSeqNo(Table **tablePtr, const char *tabrec, const int sequence)
{
TablePtr curPtr;
char *tableName = "", *recName = "", *token;
char tmpName[1024];
short i = 1;
strcpy(tmpName, tabrec);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if (i == 1)
tableName = token;
if (i == 2)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 2)
recName = "";
/* Find Table name and get record-->>dictionary */
curPtr = *tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
if (strcmp(recName, "") == 0 )
return curPtr->startPtr->getValueSeqNo(&curPtr->startPtr, curPtr->defRecordName, sequence);
else
return curPtr->startPtr->getValueSeqNo(&curPtr->startPtr, recName, sequence);
}
curPtr = curPtr->nextPtr;
}
/* No default values possible, so point of creating at this stage */
/* RETURN */
return NULL;
}
int Table::getNumEntries(Table **tablePtr, const char *tabrec)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
TablePtr curPtr, prevPtr, newPtr;
char *string, *string2, *tableName = "", *recName = "", *token, stm[255];
char *defRecName, tmpName[1024];
short insHits, i = 1;
strcpy(tmpName, tabrec);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if (i == 1)
tableName = token;
if (i == 2)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 2)
recName = "";
/* Find Table name and change record-->>dictionary */
curPtr = *tablePtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
if (strcmp(recName, "") == 0 )
return curPtr->startPtr->getNumEntries(&curPtr->startPtr, curPtr->defRecordName);
else
return curPtr->startPtr->getNumEntries(&curPtr->startPtr, recName);
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Table", tableName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Table", tableName) != 0)
return 0;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Table;
strcpy(newPtr->tableName, tableName);
/* Get External Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/ExternalName", ctxt);
strcpy(newPtr->externalName, (char *)xmlXPathCastToString(res));
/* Get Data Source Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/DataSourceName", ctxt);
strcpy(newPtr->dataSourceName, (char *)xmlXPathCastToString(res));
/* Process Records */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Get Default Record Name */
for (i = 1; i <= insHits; i++)
{
/* Check if default record */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "True") != 0)
continue;
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
defRecName = (char *)xmlXPathCastToString(res);
strcpy(newPtr->defRecordName, defRecName);
break;
}
for (i = 1; i <= insHits; i++)
{
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
/* If default record set value */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string2 = (char *)xmlXPathCastToString(res);
// if (strcmp(recName, string) == 0)
// {
// strcpy(dicRec, dicName);
// strcat(dicRec, ".");
// strcat(dicRec, recName);
// newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
// }
//
// else if ( (strcmp(recName, "") == 0) && (strcmp(string2, "Default")) )
// {
// strcpy(dicRec, dicName);
// strcat(dicRec, ".");
// strcat(dicRec, string);
// newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
// }
// else
// {
// strcpy(dicRec, dicName);
// strcat(dicRec, ".");
// if (strcmp(recName, "") == 0 )
// strcat(dicRec, curPtr->defRecordName);
// else
// strcat(dicRec, recName);
//
// newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
// }
}
if (prevPtr == NULL)
{
/* First Record */
*tablePtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
if (strcmp(recName, "") == 0 )
return newPtr->startPtr->getNumEntries(&newPtr->startPtr, newPtr->defRecordName);
else
return newPtr->startPtr->getNumEntries(&newPtr->startPtr, recName);
}
char *Table::getExternalName(Table **tablePtr, const char *name)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
TablePtr curPtr, prevPtr, newPtr;
char *string, *string2, stm[255];
char *defRecName;
short insHits, i = 1;
/* Find Table name and get external name */
curPtr = *tablePtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, name) == 0)
{
return curPtr->externalName;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Table", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "Table", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Table;
strcpy(newPtr->tableName, name);
/* Get External Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/ExternalName", ctxt);
strcpy(newPtr->externalName, (char *)xmlXPathCastToString(res));
/* Get Data Source Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/DataSourceName", ctxt);
strcpy(newPtr->dataSourceName, (char *)xmlXPathCastToString(res));
/* Process Records */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Get Default Record Name */
for (i = 1; i <= insHits; i++)
{
/* Check if default record */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "True") != 0)
continue;
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
defRecName = (char *)xmlXPathCastToString(res);
strcpy(newPtr->defRecordName, defRecName);
break;
}
for (i = 1; i <= insHits; i++)
{
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
/* If default record set value */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string2 = (char *)xmlXPathCastToString(res);
}
if (prevPtr == NULL)
{
/* First Record */
*tablePtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return newPtr->externalName;
}
char *Table::getDataSourceName(Table **tablePtr, const char *name)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
TablePtr curPtr, prevPtr, newPtr;
char *string, *string2, stm[255];
char *defRecName;
short insHits, i = 1;
/* Find Table name and get external name */
curPtr = *tablePtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, name) == 0)
{
return curPtr->dataSourceName;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
if (repGet(&docRes, biAppnPtr->getAppn(), "Table", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Table;
strcpy(newPtr->tableName, name);
/* Get External Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/ExternalName", ctxt);
strcpy(newPtr->externalName, (char *)xmlXPathCastToString(res));
/* Get Data Source */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/DataSourceName", ctxt);
strcpy(newPtr->dataSourceName, (char *)xmlXPathCastToString(res));
/* Process Records */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Get Default Record Name */
for (i = 1; i <= insHits; i++)
{
/* Check if default record */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "True") != 0)
continue;
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
defRecName = (char *)xmlXPathCastToString(res);
strcpy(newPtr->defRecordName, defRecName);
break;
}
for (i = 1; i <= insHits; i++)
{
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
/* If default record set value */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string2 = (char *)xmlXPathCastToString(res);
}
if (prevPtr == NULL)
{
/* First Record */
*tablePtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* RETURN */
return newPtr->dataSourceName;
}
int Table::getDateFormat(Table *tablePtr, const char *name)
{
char *tableName = "", *recName = "", *dicName = "", *token;
char tmpName[1024];
int i = 1;
strcpy(tmpName, name);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if ( i == 1)
dicName = token;
if (i == 2)
tableName = token;
if (i == 3)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 3)
recName = "";
/* Return date format dictionary */
return dicPtr->getDateFormat(dicPtr, dicName);
}
int Table::getDateFormatSeqNo(Table *tablePtr, const char *tabrec, const int sequence)
{
TablePtr curPtr;
char *tableName = "", *recName = "", *token;
char tmpName[1024];
short i = 1;
strcpy(tmpName, tabrec);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if (i == 1)
tableName = token;
if (i == 2)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 2)
recName = "";
/* Find Table name and get record-->>dictionary */
curPtr = tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
if (strcmp(recName, "") == 0 )
return curPtr->startPtr->getDateFormatSeqNo(curPtr->startPtr, curPtr->defRecordName, sequence);
else
return curPtr->startPtr->getDateFormatSeqNo(curPtr->startPtr, recName, sequence);
}
curPtr = curPtr->nextPtr;
}
/* No default values possible, so point of creating at this stage */
/* RETURN */
return -1;
}
void Table::putValue(Table **tablePtr, const char *name, const char *value)
{
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
TablePtr curPtr, prevPtr, newPtr;
char *string, *string2, *tableName = "", *recName = "", *dicName = "", *token, dicRec[255], stm[255];
char *defRecName, tmpName[1024];
short insHits, i = 1;
strcpy(tmpName, name);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if ( i == 1)
dicName = token;
if (i == 2)
tableName = token;
if (i == 3)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 3)
recName = "";
/* Find Table name and change record-->>dictionary */
curPtr = *tablePtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
if (strcmp(recName, "") == 0 )
strcat(dicRec, curPtr->defRecordName);
else
strcat(dicRec, recName);
curPtr->startPtr->putValue(&curPtr->startPtr, dicRec, value);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new record */
//docRes = RC_Get(biAppnPtr->getAppn(), "Table", tableName);
if (repGet(&docRes, biAppnPtr->getAppn(), "Table", tableName) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Table;
strcpy(newPtr->tableName, tableName);
/* Get External Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/ExternalName", ctxt);
strcpy(newPtr->externalName, (char *)xmlXPathCastToString(res));
/* Get Data Source Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Table/DataSourceName", ctxt);
strcpy(newPtr->dataSourceName, (char *)xmlXPathCastToString(res));
/* Process Records */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry)", ctxt);
insHits = (short)xmlXPathCastToNumber(res);
/* Get Default Record Name */
for (i = 1; i <= insHits; i++)
{
/* Check if default record */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
if (strcmp(string, "True") != 0)
continue;
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
defRecName = (char *)xmlXPathCastToString(res);
strcpy(newPtr->defRecordName, defRecName);
break;
}
for (i = 1; i <= insHits; i++)
{
/* Get Record Name */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/RecordName", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
/* If default record set value */
sprintf(stm, "/ProLinga/Repository/Command/Object/Table/OccurrencesTableRecordEntry/TableRecordEntry[%d]/@Default", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string2 = (char *)xmlXPathCastToString(res);
if (strcmp(recName, string) == 0)
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
strcat(dicRec, recName);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, value);
}
else if ( (strcmp(recName, "") == 0) && (strcmp(string2, "Default")) )
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
strcat(dicRec, string);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, value);
}
else
{
strcpy(dicRec, dicName);
strcat(dicRec, ".");
if (strcmp(recName, "") == 0 )
strcat(dicRec, curPtr->defRecordName);
else
strcat(dicRec, recName);
newPtr->startPtr->putValue(&newPtr->startPtr, dicRec, "");
}
}
if (prevPtr == NULL)
{
/* First Record */
*tablePtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
}
void Table::putValueSeqNo(Table **tablePtr, const char *tabrec, const int sequence, const char *value)
{
char tmpName[255], *tableName, *recName, *token;
int i = 1;
TablePtr curPtr;
strcpy(tmpName, tabrec);
token = strtok((char *)tmpName, ".");
while (token != NULL)
{
if (i == 1)
tableName = token;
if (i == 2)
recName = token;
token = strtok(NULL, ".");
i++;
}
if ( i == 2)
recName = "";
/* Find Table name*/
curPtr = *tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
if (strcmp(recName, "") == 0 )
{
return curPtr->startPtr->putValueSeqNo(&curPtr->startPtr, curPtr->defRecordName, sequence, value);
}
else
return curPtr->startPtr->putValueSeqNo(&curPtr->startPtr, recName, sequence, value);
}
curPtr = curPtr->nextPtr;
}
}
void Table::clearOneRecord(Table **tablePtr, const char *tableName, const char *recordName)
{
Table *curPtr;
curPtr = *tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, tableName) == 0)
{
/* Clear Record */
curPtr->startPtr->clearOne(&curPtr->startPtr, recordName);
}
curPtr = curPtr->nextPtr;
}
}
void Table::deleteOne(Table **tablePtr, const char *name)
{
Table *prevPtr, *curPtr, *nextPtr;
prevPtr = NULL;
curPtr = *tablePtr;
nextPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
if (strcmp(curPtr->tableName, name) == 0)
{
/* Unlink Table */
if (prevPtr == NULL)
*tablePtr = nextPtr;
else
prevPtr->nextPtr = nextPtr;
/* Delete Record List */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete Xml Doc */
//if (curPtr->docTable != NULL)
//xmlFreeDoc(curPtr->docTable);
/* Delete Table */
delete curPtr;
}
prevPtr = curPtr;
curPtr = nextPtr;
}
}
void Table::deleteList(Table **tablePtr)
{
Table *curPtr, *nextPtr, *tmpPtr;
/* Init */
curPtr = *tablePtr;
nextPtr = NULL;
*tablePtr = NULL;
while (curPtr != NULL)
{
/* Look ahead */
nextPtr = curPtr->nextPtr;
/* Delete Record List */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete Xml Doc */
//if (curPtr->docTable != NULL)
// xmlFreeDoc(curPtr->docTable);
/* Delete Table */
tmpPtr = curPtr;
curPtr = nextPtr;
delete tmpPtr;
}
}
void Table::printList(Table *tablePtr) const
{
Table *curPtr;
curPtr = tablePtr;
while (curPtr != NULL)
{
printf("Table Name %s\n", curPtr->tableName);
curPtr->startPtr->printList(curPtr->startPtr);
curPtr = curPtr->nextPtr;
}
}
xmlDocPtr Table::getDocBuffer(Table **tablePtr, const char *name)
{
Table *curPtr;
xmlDocPtr docBuf = NULL;
curPtr = *tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, name) == 0)
{
/* return buffer */
docBuf = xmlCopyDoc(curPtr->docTable, 1);
//return docBuf;
//return curPtr->docTable;
break;
}
curPtr = curPtr->nextPtr;
}
return docBuf;
}
void Table::putDocBuffer(Table **tablePtr, const char *name, const xmlDocPtr docBuf)
{
Table *curPtr;
curPtr = *tablePtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->tableName, name) == 0)
{
/* Delete existing buffer */
//if (curPtr->docTable != NULL)
// xmlFreeDoc(curPtr->docTable);
/* Put new buffer in place */
curPtr->docTable = xmlCopyDoc(docBuf,1);
break;
}
curPtr = curPtr->nextPtr;
}
}
PickListEntry::PickListEntry()
{
entry = 0;
plentryValue = NULL;
nextPtr = NULL;
}
PickListEntry::~PickListEntry()
{
delete plentryValue;
}
void PickListEntry::initList(PickListEntry **plentryPtr, const char *name)
{
PickListEntry *curPtr, *newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *string, stm[1024];
int insHits, i,j;
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "PickList", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "PickList", name) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Process Entries */
res = xmlXPathEval((const xmlChar *)"count(/ProLinga/Repository/Command/Object/PickList/OccurrencesPickListEntry/PickListEntry)", ctxt);
insHits = (int)xmlXPathCastToNumber(res);
curPtr = NULL;
for (i = 1; i <= insHits; i++)
{
sprintf(stm, "/ProLinga/Repository/Command/Object/PickList/OccurrencesPickListEntry/PickListEntry[%d]/Value", i);
res = xmlXPathEval((const xmlChar *)stm, ctxt);
string = (char *)xmlXPathCastToString(res);
newPtr = new PickListEntry;
newPtr->entry = i;
j = strlen(string);
newPtr->plentryValue = new char[j+1];
strcpy(newPtr->plentryValue, string);
if (curPtr == NULL)
*plentryPtr = newPtr;
else
curPtr->nextPtr = newPtr;
curPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
}
char *PickListEntry::getValue(PickListEntry **plentryPtr, const int entry)
{
PickListEntry *curPtr;
/* Check if entry exist in memory */
curPtr = *plentryPtr;
while (curPtr != NULL)
{
if (curPtr->entry == entry)
return curPtr->plentryValue;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *PickListEntry::getValuePtr(PickListEntry **plentryPtr, const int entry)
{
PickListEntry *curPtr;
/* Check if entry exist in memory */
curPtr = *plentryPtr;
while (curPtr != NULL)
{
if (curPtr->entry == entry)
return curPtr->plentryValue;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
void PickListEntry::putValue(PickListEntry **plentryPtr, const int entry, const char *value)
{
PickListEntry *curPtr, *prevPtr, *newPtr;
int i,j;
/* Check if entry exists in memlist */
curPtr = *plentryPtr;
prevPtr = NULL;
i = 0;
while (curPtr != NULL)
{
i = curPtr->entry;
if (curPtr->entry == entry)
{
/* Delete existing value */
delete curPtr->plentryValue;
curPtr->plentryValue = new char[strlen(value)+1];
strcpy(curPtr->plentryValue, value);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create empty entries */
j = entry - i - 1;
for (i=1; i<=j; i++)
{
newPtr = new PickListEntry;
if (prevPtr == NULL)
*plentryPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
prevPtr = newPtr;
}
/* Append new item */
newPtr = new PickListEntry;
newPtr->plentryValue = new char[strlen(value)+1];
strcpy(curPtr->plentryValue, value);
if (prevPtr == NULL)
*plentryPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
}
void PickListEntry::deleteList(PickListEntry **plentryPtr)
{
PickListEntryPtr curPtr, tmpPtr;
curPtr = *plentryPtr;
*plentryPtr = NULL;
while (curPtr != NULL)
{
tmpPtr = curPtr;
curPtr = curPtr->nextPtr;
delete tmpPtr;
}
}
void PickListEntry::printList(PickListEntry *plentryPtr) const
{
PickListEntry *curPtr;
curPtr = plentryPtr;
while (curPtr != NULL)
{
printf("Pick List Entry %d\n", curPtr->entry);
printf("Pick List Entry Value %s\n", curPtr->plentryValue);
curPtr = curPtr->nextPtr;
}
}
//void PickListEntry::populateGList(PickListEntry *plentryPtr, GList ***items)
//{
// PickListEntry *curPtr;
// curPtr = plentryPtr;
// while (curPtr != NULL)
// {
// **items = g_list_append (**items, curPtr->plentryValue);
// curPtr = curPtr->nextPtr;
// }
//}
int PickListEntry::tableCount(PickListEntry *plentryPtr)
{
PickListEntry *curPtr;
int count = 0;
curPtr = plentryPtr;
while (curPtr != NULL)
{
count++;
curPtr = curPtr->nextPtr;
}
return count;
}
PickList::PickList()
{
strcpy(pickName, "");
startPtr = NULL;
nextPtr = NULL;
}
PickList::~PickList()
{
// Delete PickListEntry List?
}
char *PickList::getValue(PickList **pickPtr, const char *name)
{
PickListPtr curPtr, prevPtr, newPtr;
char tempName[255]="\0", *token, *pickListName = "";
int entry, i;
strcpy(tempName, name);
token = strtok(tempName, "(");
i = 1;
while (token != NULL)
{
if (i == 1)
pickListName = token;
if (i == 2)
entry = atoi(token);
token = strtok(NULL, ")");
i++;
}
/* Find Pick List Name */
curPtr = *pickPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->pickName, pickListName) == 0)
return curPtr->startPtr->getValue(&curPtr->startPtr, entry);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new Pick List */
newPtr = new PickList;
strcpy(newPtr->pickName, pickListName);
/* Populate Items */
newPtr->startPtr->initList(&newPtr->startPtr, pickListName);
if (prevPtr == NULL)
{
/* First Record */
*pickPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Return */
return newPtr->startPtr->getValue(&newPtr->startPtr, entry);
}
char *PickList::getValueEntry(PickList **pickPtr, const char *name, const int entry)
{
PickListPtr curPtr, prevPtr, newPtr;
/* Find PickList Name */
curPtr = *pickPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->pickName, name) == 0)
return curPtr->startPtr->getValue(&curPtr->startPtr, entry);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new PickList */
newPtr = new PickList;
strcpy(newPtr->pickName, name);
/* Populate Items */
newPtr->startPtr->initList(&newPtr->startPtr, name);
if (prevPtr == NULL)
{
/* First Record */
*pickPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Return */
return newPtr->startPtr->getValue(&newPtr->startPtr, entry);
}
char *PickList::getValueEntryPtr(PickList **pickPtr, const char *name, const int entry)
{
PickListPtr curPtr, prevPtr, newPtr;
/* Find PickList Name */
curPtr = *pickPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->pickName, name) == 0)
{
return curPtr->startPtr->getValuePtr(&curPtr->startPtr, entry);
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new Pick List */
newPtr = new PickList;
strcpy(newPtr->pickName, name);
/* Populate Items */
newPtr->startPtr->initList(&newPtr->startPtr, name);
if (prevPtr == NULL)
{
/* First Record */
*pickPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Get Value */
return newPtr->startPtr->getValuePtr(&newPtr->startPtr, entry);
}
void PickList::putValue(PickList **pickPtr, const char *name, const char *value)
{
PickListPtr curPtr, prevPtr, newPtr;
char pickListName[64]="\0", *string;
char temp[64];
int entry, len;
short pos;
/* Get PickList Name */
strcpy(pickListName, "");
len = strcspn(name, "(");
strncpy(pickListName, name, len);
/* Get entry number */
strcpy(temp, name);
string = temp + len + 1;
pos = strcspn(string, ")");
strcpy(temp, string);
temp[pos] = '\0';
entry = atoi(temp);
/* Find PickList Name */
curPtr = *pickPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->pickName, pickListName) == 0)
{
curPtr->startPtr->putValue(&curPtr->startPtr, entry, value);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new Pick List */
newPtr = new PickList;
strcpy(newPtr->pickName, pickListName);
/* Populate Items */
newPtr->startPtr->initList(&newPtr->startPtr, pickListName);
/* Get Value */
newPtr->startPtr->putValue(&newPtr->startPtr, entry, value);
if (prevPtr == NULL)
{
/* First Record */
*pickPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
}
void PickList::deleteList(PickList **pickPtr)
{
PickListPtr curPtr, tmpPtr;
curPtr = *pickPtr;
*pickPtr = NULL;
while (curPtr != NULL)
{
tmpPtr = curPtr;
curPtr = curPtr->nextPtr;
delete tmpPtr;
}
}
void PickList::printList(PickList *pickPtr) const
{
PickList *curPtr;
curPtr = pickPtr;
while (curPtr != NULL)
{
curPtr->startPtr->printList(curPtr->startPtr);
curPtr = curPtr->nextPtr;
}
}
int PickList::tableCount(PickList **pickPtr, const char *name)
{
PickList *curPtr, *prevPtr, *newPtr;
int count = 0;
prevPtr = NULL;
curPtr = *pickPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->pickName, name) == 0)
{
count = curPtr->startPtr->tableCount(curPtr->startPtr);
return count;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Create new Pick List */
newPtr = new PickList;
strcpy(newPtr->pickName, name);
/* Populate Items */
newPtr->startPtr->initList(&newPtr->startPtr, name);
if (prevPtr == NULL)
{
/* First Record */
*pickPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Populate list */
count = newPtr->startPtr->tableCount(newPtr->startPtr);
return count;
}
//void PickList::populateGList(PickList **pickPtr, GListPtr *items, const char *name)
//{
// PickList *curPtr, *prevPtr, *newPtr;
//
// prevPtr = NULL;
// curPtr = *pickPtr;
//
// while (curPtr != NULL)
// {
// if (strcmp(curPtr->pickName, name) == 0)
// {
// curPtr->startPtr->populateGList(curPtr->startPtr, &items);
// return;
// }
// prevPtr = curPtr;
// curPtr = curPtr->nextPtr;
// }
/* Create new Pick List */
// newPtr = new PickList;
// strcpy(newPtr->pickName, name);
/* Populate Items */
// newPtr->startPtr->initList(&newPtr->startPtr, name);
// if (prevPtr == NULL)
// {
// /* First Record */
// *pickPtr = newPtr;
// }
// else
// {
// prevPtr->nextPtr = newPtr;
// }
//
// /* Populate list */
// newPtr->startPtr->populateGList(newPtr->startPtr, &items);
//}
Constant::Constant()
{
strcpy(consName, "");
strcpy(dicName, "");
startPtr = NULL;
nextPtr = NULL;
}
Constant::~Constant()
{
/* Delete DataDictionary List */
// if (startPtr != NULL)
// startPtr->deleteList(&startPtr);
}
char *Constant::getValue(ConstantPtr *consPtr, const char *name)
{
ConstantPtr curPtr, prevPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *value;
/* Check if constant exist in memory */
curPtr = *consPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->consName, name) == 0)
return curPtr->startPtr->getValue(&curPtr->startPtr, curPtr->dicName);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "Constant", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "Constant", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Constant;
strcpy(newPtr->consName, name);
/* Data Dictionary Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Constant/DataDictionaryName", ctxt);
strcpy(newPtr->dicName, (char *)xmlXPathCastToString(res));
/* Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Constant/Value", ctxt);
value = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, newPtr->dicName, 1, value);
if (prevPtr == NULL)
{
/* First Record */
*consPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValue(&newPtr->startPtr, newPtr->dicName);
}
char *Constant::getValueData(ConstantPtr *consPtr, const char *name, int &retLength, char &retPadChar, char &retJustification)
{
ConstantPtr curPtr, prevPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *value;
/* Check if constant exist in memory */
curPtr = *consPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->consName, name) == 0)
return curPtr->startPtr->getValueData(&curPtr->startPtr, curPtr->dicName, retLength, retPadChar, retJustification);
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "Constant", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "Constant", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new Constant;
strcpy(newPtr->consName, name);
/* Data Dictionary Name */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Constant/DataDictionaryName", ctxt);
strcpy(newPtr->dicName, (char *)xmlXPathCastToString(res));
/* Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Constant/Value", ctxt);
value = (char *)xmlXPathCastToString(res);
newPtr->startPtr->putValue(&newPtr->startPtr, newPtr->dicName, 1, value);
if (prevPtr == NULL)
{
/* First Record */
*consPtr = newPtr;
}
else
{
prevPtr->nextPtr = newPtr;
}
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->startPtr->getValueData(&newPtr->startPtr, newPtr->dicName, retLength, retPadChar, retJustification);
}
int Constant::getDateFormat(Constant *consPtr, const char *name)
{
Constant *curPtr;
/* Check if variable exist in memory */
curPtr = consPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->consName, name) == 0)
return curPtr->startPtr->getDateFormat(curPtr->startPtr, curPtr->dicName);
curPtr = curPtr->nextPtr;
}
/* Return */
return -1;
}
void Constant::deleteOne(Constant **consPtr, const char *name)
{
Constant *prevPtr, *curPtr, *nextPtr;
prevPtr = NULL;
curPtr = *consPtr;
nextPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
if (strcmp(curPtr->consName, name) == 0)
{
/* Unlink Constant */
if (prevPtr == NULL)
*consPtr = nextPtr;
else
prevPtr->nextPtr = nextPtr;
/* Delete DataDictionary */
curPtr->startPtr->deleteList(&curPtr->startPtr);
/* Delete Constant */
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = nextPtr;
}
}
void Constant::deleteList(ConstantPtr *consPtr)
{
ConstantPtr tmpPtr;
while (*consPtr != NULL)
{
tmpPtr = *consPtr;
*consPtr = (*consPtr)->nextPtr;
tmpPtr->startPtr->deleteList(&tmpPtr->startPtr);
delete tmpPtr;
}
}
void Constant::printList(ConstantPtr consPtr) const
{
ConstantPtr curPtr;
curPtr = consPtr;
while (curPtr != NULL)
{
printf("Constant Name %s\n", curPtr->consName);
curPtr->startPtr->printList(curPtr->startPtr);
curPtr = curPtr->nextPtr;
}
}
DataModelEntry::DataModelEntry()
{
colNo = 0;
colName = NULL;
dataValue = NULL;
dataLength = 0;
nextPtr = NULL;
}
DataModelEntry::~DataModelEntry()
{
if (colName != NULL)
delete colName;
if (dataValue != NULL)
delete dataValue;
}
char *DataModelEntry::getDataValueColNo(DataModelEntryPtr dmentryPtr, const int col)
{
DataModelEntryPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmentryPtr;
while (curPtr != NULL)
{
if (curPtr->colNo == col)
return curPtr->dataValue;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *DataModelEntry::getDataValueColName(DataModelEntryPtr dmentryPtr, const char *colname)
{
DataModelEntryPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmentryPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->colName, colname) == 0)
return curPtr->dataValue;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *DataModelEntry::getColName(DataModelEntryPtr dmentryPtr, const int col)
{
DataModelEntryPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmentryPtr;
while (curPtr != NULL)
{
if (curPtr->colNo == col)
return curPtr->colName;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
void DataModelEntry::putDataValue(DataModelEntryPtr *dmentryPtr, const int col, const char *colname, const char *value, const int length)
{
DataModelEntryPtr curPtr, prevPtr, newPtr;
/* Check if data model entry exist in memory */
curPtr = *dmentryPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (curPtr->colNo == col)
{
if (curPtr->colName != NULL)
delete curPtr->colName;
if (curPtr->dataValue != NULL)
delete curPtr->dataValue;
curPtr->colName = new char[(strlen(colname)+1)];
strcpy(curPtr->colName, colname);
curPtr->dataValue = new char[(strlen(value)+1)];
strcpy(curPtr->dataValue, value);
curPtr->dataLength = length;
/* Return */
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Append new record */
newPtr = new DataModelEntry;
newPtr->colNo = col;
newPtr->colName = new char[(strlen(colname)+1)];
strcpy(newPtr->colName, colname);
newPtr->dataValue = new char[(strlen(value)+1)];
strcpy(newPtr->dataValue, value);
newPtr->dataLength = length;
/* Prepend in list */
if (prevPtr == NULL)
*dmentryPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
}
void DataModelEntry::updateDataValue(DataModelEntryPtr *dmentryPtr, const int col, const char *value)
{
DataModelEntryPtr curPtr, prevPtr;
/* Check if data model entry exist in memory */
curPtr = *dmentryPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (curPtr->colNo == col)
{
if (curPtr->dataValue != NULL)
delete curPtr->dataValue;
curPtr->dataValue = new char[(strlen(value)+1)];
strcpy(curPtr->dataValue, value);
/* Return */
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
}
void DataModelEntry::updateDataValueName(DataModelEntryPtr *dmentryPtr, const char *name, const char *value)
{
DataModelEntryPtr curPtr, prevPtr;
/* Check if data model entry exist in memory */
curPtr = *dmentryPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->colName, name) == 0)
{
if (curPtr->dataValue != NULL)
delete curPtr->dataValue;
curPtr->dataValue = new char[(strlen(value)+1)];
strcpy(curPtr->dataValue, value);
/* Return */
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
}
void DataModelEntry::deleteList(DataModelEntry **dmentryPtr)
{
DataModelEntryPtr curPtr, tmpPtr;
curPtr = *dmentryPtr;
*dmentryPtr = NULL;
while (curPtr != NULL)
{
tmpPtr = curPtr;
curPtr = curPtr->nextPtr;
delete tmpPtr;
}
}
void DataModelEntry::printList(DataModelEntry *dmentryPtr) const
{
DataModelEntry *curPtr;
curPtr = dmentryPtr;
while (curPtr != NULL)
{
printf("Data Model Entry Column No %d\n", curPtr->colNo);
printf("Data Model Entry Column Name %s\n", curPtr->colName);
printf("Data Model Entry Data Value %s\n", curPtr->dataValue);
curPtr = curPtr->nextPtr;
}
}
DataModel::DataModel()
{
strcpy(dmName, "");
dmDataSource = NULL;
dmNumberCols = 0;
dmNumberRows = 0;
dmCurrentRow = 0;
startPtr = NULL;
nextPtr = NULL;
}
DataModel::~DataModel()
{
if (dmDataSource != NULL)
delete dmDataSource;
if (startPtr != NULL)
startPtr->deleteList(&startPtr);
}
bool DataModel::existsDataModel(DataModel *dmPtr, const char *name)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return true;
curPtr = curPtr->nextPtr;
}
/* Return */
return false;
}
char *DataModel::getDataSource(DataModelPtr dmPtr, const char *name)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->dmDataSource;
curPtr = curPtr->nextPtr;
}
/* Return */
return 0;
}
int DataModel::getColumns(DataModelPtr dmPtr, const char *name)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->dmNumberCols;
curPtr = curPtr->nextPtr;
}
/* Return */
return 0;
}
int DataModel::getRows(DataModelPtr dmPtr, const char *name)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->dmNumberRows;
curPtr = curPtr->nextPtr;
}
/* Return */
return 0;
}
int DataModel::getCurrentRow(DataModelPtr dmPtr, const char *name)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->dmCurrentRow;
curPtr = curPtr->nextPtr;
}
/* Return */
return 0;
}
void DataModel::putDataSource(DataModelPtr *dmPtr, const char *name, const char *dataSource)
{
DataModelPtr curPtr, prevPtr, newPtr;
/* Check if data model exist in memory */
curPtr = *dmPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
{
if (curPtr->dmDataSource != NULL)
delete curPtr->dmDataSource;
curPtr->dmDataSource = new char[(strlen(dataSource)+1)];
strcpy(curPtr->dmDataSource, dataSource);
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Append new record */
newPtr = new DataModel;
strcpy(newPtr->dmName, name);
/* Set data Source */
newPtr->dmDataSource = new char[(strlen(dataSource)+1)];
strcpy(newPtr->dmDataSource, dataSource);
/* Prepend in list */
if (prevPtr == NULL)
*dmPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
}
void DataModel::putColumns(DataModelPtr *dmPtr, const char *name, const int numberCols)
{
DataModelPtr curPtr, prevPtr, newPtr;
/* Check if data model exist in memory */
curPtr = *dmPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
{
curPtr->dmNumberCols = numberCols;
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Append new record */
newPtr = new DataModel;
strcpy(newPtr->dmName, name);
/* Set number of columns */
newPtr->dmNumberCols = numberCols;
/* Prepend in list */
if (prevPtr == NULL)
*dmPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
}
void DataModel::putRows(DataModelPtr *dmPtr, const char *name, const int numberRows)
{
DataModelPtr curPtr, prevPtr, newPtr;
//xmlDocPtr docRes = NULL;
//xmlXPathContextPtr ctxt;
//xmlXPathObjectPtr res;
/* Check if data model exist in memory */
curPtr = *dmPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
{
curPtr->dmNumberRows = numberRows;
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
// docRes = RC_Get(biAppnPtr->getAppn(), "DataModel", name);
//if (repGet(&docRes, biAppnPtr->getAppn(), "DataModel", name) != 0)
// return;
/* Init XPath */
// xmlXPathInit();
/* Create XPath environment */
// ctxt = xmlXPathNewContext(docRes);
/* Append new record */
newPtr = new DataModel;
strcpy(newPtr->dmName, name);
/* Set number of rows */
newPtr->dmNumberRows = numberRows;
/* Data Dictionary Name */
// res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/Constant/DataDictionaryName", ctxt);
// strcpy(newPtr->dicName, (char *)xmlXPathCastToString(res));
/* Prepend in list */
if (prevPtr == NULL)
*dmPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
/* Cleanup */
// xmlFreeDoc(docRes);
}
void DataModel::putCurrentRow(DataModelPtr *dmPtr, const char *name, const int currentRow)
{
DataModelPtr curPtr, prevPtr, newPtr;
/* Check if data model exist in memory */
curPtr = *dmPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
{
curPtr->dmCurrentRow = currentRow;
return;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Append new record */
newPtr = new DataModel;
strcpy(newPtr->dmName, name);
/* Set number of rows */
newPtr->dmCurrentRow = currentRow;
/* Prepend in list */
if (prevPtr == NULL)
*dmPtr = newPtr;
else
prevPtr->nextPtr = newPtr;
}
char *DataModel::getValue(DataModel *dmPtr, const char *reference)
{
char *tmpRef, *token, *dataName, *dataModelName;
int i, colNo;
tmpRef = new char[(strlen(reference)+1)];
strcpy(tmpRef, reference);
token = strtok((char *)tmpRef, ".");
i = 1;
while (token != NULL)
{
if (i == 1)
dataName = token;
if (i == 2)
dataModelName = token;
token = strtok(NULL, ".");
i++;
}
/* Check if colxx specified or name/alias */
if (strncmp(dataName, "_col_", 5) == 0)
{
colNo = atoi(dataName+5);
return dmPtr->getDataValueColNo(dmPtr, dataModelName, colNo);
}
else
{
return dmPtr->getDataValueColName(dmPtr, dataModelName, dataName);
}
/* Clean up */
delete tmpRef;
}
char *DataModel::getDataValueColNo(DataModel *dmPtr, const char *name, const int col)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->startPtr->getDataValueColNo(curPtr->startPtr, col);
curPtr = curPtr->nextPtr;
}
return NULL;
}
char *DataModel::getDataValueColName(DataModel *dmPtr, const char *name, const char *colname)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->startPtr->getDataValueColName(curPtr->startPtr, colname);
curPtr = curPtr->nextPtr;
}
return NULL;
}
char *DataModel::getColName(DataModel *dmPtr, const char *name, const int col)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
return curPtr->startPtr->getColName(curPtr->startPtr, col);
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
void DataModel::putDataValue(DataModel **dmPtr, const char *name, const int col, const char *colname, const char *value, const int length)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = *dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
{
curPtr->startPtr->putDataValue(&curPtr->startPtr, col, colname, value, length);
break;
}
curPtr = curPtr->nextPtr;
}
}
void DataModel::updateDataValue(DataModel **dmPtr, const char *name, const int col, const char *value)
{
DataModelPtr curPtr;
/* Check if data model exist in memory */
curPtr = *dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, name) == 0)
{
curPtr->startPtr->updateDataValue(&curPtr->startPtr, col, value);
break;
}
curPtr = curPtr->nextPtr;
}
}
void DataModel::updateDataValueCol(DataModel **dmPtr, const char *name, const char *value)
{
DataModelPtr curPtr;
char *tmpRef, *dataName, *dataModelName, *token;
int i, colNo = 0;
/* Split data model name from data name */
tmpRef = new char[(strlen(name)+1)];
strcpy(tmpRef, name);
token = strtok((char *)tmpRef, ".");
i = 1;
while (token != NULL)
{
if (i == 1)
dataName = token;
if (i == 2)
dataModelName = token;
token = strtok(NULL, ".");
i++;
}
/* Check if data model exist in memory */
curPtr = *dmPtr;
while (curPtr != NULL)
{
if (strcmp(curPtr->dmName, dataModelName) == 0)
{
/* Check if colxx specified or name/alias */
if (strncmp(dataName, "_col_", 5) == 0)
{
colNo = atoi(dataName+5);
curPtr->startPtr->updateDataValue(&curPtr->startPtr, colNo, value);
break;
}
else
{
curPtr->startPtr->updateDataValueName(&curPtr->startPtr, dataName, value);
break;
}
}
curPtr = curPtr->nextPtr;
}
/* Clean up */
delete tmpRef;
}
void DataModel::deleteOne(DataModel **dmPtr, const char *name)
{
DataModel *prevPtr, *curPtr, *nextPtr;
prevPtr = NULL;
curPtr = *dmPtr;
nextPtr = NULL;
while (curPtr != NULL)
{
nextPtr = curPtr->nextPtr;
if (strcmp(curPtr->dmName, name) == 0)
{
/* Unlink DataModel */
if (prevPtr == NULL)
*dmPtr = nextPtr;
else
prevPtr->nextPtr = nextPtr;
/* Delete DataModel */
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = nextPtr;
}
}
void DataModel::deleteList(DataModelPtr *dmPtr)
{
DataModelPtr tmpPtr;
while (*dmPtr != NULL)
{
tmpPtr = *dmPtr;
*dmPtr = (*dmPtr)->nextPtr;
delete tmpPtr;
}
}
void DataModel::printList(DataModelPtr dmPtr) const
{
DataModelPtr curPtr;
curPtr = dmPtr;
while (curPtr != NULL)
{
printf("Data Model Name %s\n", curPtr->dmName);
curPtr = curPtr->nextPtr;
}
}
TextDocument::TextDocument()
{
strcpy(txtName, "");
txtValue = NULL;
nextPtr = NULL;
}
TextDocument::~TextDocument()
{
/* Nothing ? */
}
char *TextDocument::getValue(TextDocumentPtr *txtPtr, const char *name)
{
TextDocumentPtr curPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
curPtr = *txtPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->txtName, name) == 0)
return curPtr->txtValue;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "TextDocument", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "TextDocument", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Prepend new record */
newPtr = new TextDocument;
strcpy(newPtr->txtName, name);
/* Get Text Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/TextDocument/TextContents", ctxt);
newPtr->txtValue = new char[strlen((char *)xmlXPathCastToString(res))+1];
strcpy(newPtr->txtValue, (char *)xmlXPathCastToString(res));
newPtr->nextPtr = *txtPtr;
*txtPtr = newPtr;
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->txtValue;
}
void TextDocument::appendStringValue(TextDocumentPtr *txtPtr, const char *name, const char *value)
{
TextDocumentPtr curPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
char *tmpValue;
curPtr = *txtPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->txtName, name) == 0)
{
if (curPtr->txtValue == NULL)
{
curPtr->txtValue = new char[strlen(value)+1];
strcpy(curPtr->txtValue, value);
return;
}
else
{
tmpValue = new char[strlen(curPtr->txtValue)+1];
strcpy(tmpValue, curPtr->txtValue);
delete curPtr->txtValue;
curPtr->txtValue = new char[strlen(tmpValue)+strlen(value)+1];
strcpy(curPtr->txtValue, tmpValue);
strcat(curPtr->txtValue, value);
delete tmpValue;
return;
}
}
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "TextDocument", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "TextDocument", name) != 0)
return;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Prepend new record */
newPtr = new TextDocument;
strcpy(newPtr->txtName, name);
/* Get Text Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/TextDocument/TextContents", ctxt);
newPtr->txtValue = new char[strlen((char *)xmlXPathCastToString(res))+strlen(value)+1];
strcpy(newPtr->txtValue, (char *)xmlXPathCastToString(res));
newPtr->nextPtr = *txtPtr;
*txtPtr = newPtr;
/* Append value */
if (strlen(newPtr->txtValue) == 0)
strcpy(newPtr->txtValue, value);
else
strcat(newPtr->txtValue, value);
/* Cleanup */
xmlFreeDoc(docRes);
}
void TextDocument::clearDocument(TextDocumentPtr *txtPtr, const char *name)
{
TextDocumentPtr curPtr;
curPtr = *txtPtr;
/* Find out if Document exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->txtName, name) == 0)
{
if (curPtr->txtValue != NULL)
{
delete curPtr->txtValue;
curPtr->txtValue = new char [2];
strcpy(curPtr->txtValue, "");
}
return;
}
curPtr = curPtr->nextPtr;
}
}
void TextDocument::deleteDocument(TextDocumentPtr *txtPtr, const char *name)
{
TextDocumentPtr curPtr, prevPtr;
curPtr = *txtPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->txtName, name) == 0)
{
if (prevPtr == NULL)
*txtPtr = curPtr->nextPtr;
else
prevPtr->nextPtr = curPtr->nextPtr;
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
}
void TextDocument::deleteList(TextDocumentPtr *txtPtr)
{
TextDocumentPtr tmpPtr;
while (*txtPtr != NULL)
{
tmpPtr = *txtPtr;
*txtPtr = (*txtPtr)->nextPtr;
delete tmpPtr;
}
}
void TextDocument::printList(TextDocumentPtr txtPtr) const
{
TextDocumentPtr curPtr;
curPtr = txtPtr;
while (curPtr != NULL)
{
printf("Value %s\n", curPtr->txtName);
curPtr = curPtr->nextPtr;
}
}
XmlDocument::XmlDocument()
{
strcpy(xmlName, "");
rootElementName = NULL;
navPath = NULL;
docXml = NULL;
curXml = NULL;
//ctxXml = NULL;
nextPtr = NULL;
}
XmlDocument::~XmlDocument()
{
if (rootElementName != NULL)
delete rootElementName;
if (navPath != NULL)
delete navPath;
if (docXml != NULL)
xmlFreeDoc(docXml);
}
xmlDocPtr XmlDocument::getDocument(XmlDocumentPtr *xmlPtr, const char *name)
{
XmlDocumentPtr curPtr, newPtr;
xmlDocPtr docRes = NULL;
xmlXPathContextPtr ctxt;
xmlXPathObjectPtr res;
curPtr = *xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
return curPtr->docXml;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "XmlDocument", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "XmlDocument", name) != 0)
return NULL;
/* Init XPath */
xmlXPathInit();
/* Create XPath environment */
ctxt = xmlXPathNewContext(docRes);
/* Prepend new record */
newPtr = new XmlDocument;
strcpy(newPtr->xmlName, name);
/* Get Xml Root Element Value */
res = xmlXPathEval((const xmlChar *)"/ProLinga/Repository/Command/Object/XmlDocument/RootElementName", ctxt);
newPtr->rootElementName = new char[(strlen((char *)xmlXPathCastToString(res)) + 1)];
strcpy(newPtr->rootElementName, (char *)xmlXPathCastToString(res));
newPtr->docXml = xmlNewDoc((const xmlChar *)XML_VERSION);
newPtr->docXml->children = xmlNewDocNode(newPtr->docXml, NULL, (const xmlChar *)(char *)xmlXPathCastToString(res), NULL);
newPtr->curXml = xmlDocGetRootElement(newPtr->docXml);
/* Set navigation path */
newPtr->navPath = new char[(strlen((char *)xmlXPathCastToString(res)) + 2)];
sprintf(newPtr->navPath,"/%s", (char *)xmlXPathCastToString(res));
/* Create XPath environment */
// newPtr->ctxXml = xmlXPathNewContext(newPtr->docXml);
/* Set Pointers */
newPtr->nextPtr = *xmlPtr;
*xmlPtr = newPtr;
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return newPtr->docXml;
}
xmlNodePtr XmlDocument::getNode(XmlDocumentPtr xmlPtr, const char *name)
{
XmlDocumentPtr curPtr;
curPtr = xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
return curPtr->curXml;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *XmlDocument::getRootElementName(XmlDocumentPtr xmlPtr, const char *name)
{
XmlDocumentPtr curPtr;
curPtr = xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
return curPtr->rootElementName;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
char *XmlDocument::getNavPath(XmlDocumentPtr xmlPtr, const char *name)
{
XmlDocumentPtr curPtr;
curPtr = xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
return curPtr->navPath;
curPtr = curPtr->nextPtr;
}
/* Return */
return NULL;
}
void XmlDocument::putDocument(XmlDocumentPtr *xmlPtr, const char *name, xmlDocPtr doc)
{
XmlDocumentPtr curPtr, newPtr, prevPtr;
xmlDocPtr docRes = NULL;
curPtr = *xmlPtr;
prevPtr = NULL;
/* Delete document with same name if exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
{
if (prevPtr == NULL)
*xmlPtr = curPtr->nextPtr;
else
prevPtr->nextPtr = curPtr->nextPtr;
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
/* Check Repository */
//docRes = RC_Get(biAppnPtr->getAppn(), "XmlDocument", name);
if (repGet(&docRes, biAppnPtr->getAppn(), "XmlDocument", name) != 0)
return;
/* Prepend new record */
newPtr = new XmlDocument;
strcpy(newPtr->xmlName, name);
newPtr->docXml = doc;
newPtr->curXml = xmlDocGetRootElement(newPtr->docXml);
newPtr->rootElementName = new char[(strlen((const char *)newPtr->curXml->name)+1)];
strcpy(newPtr->rootElementName, (const char *)newPtr->curXml->name);
newPtr->navPath = new char[(strlen((const char *)newPtr->curXml->name)+2)];
sprintf(newPtr->navPath,"/%s", newPtr->rootElementName);
/* Set Pointers */
newPtr->nextPtr = *xmlPtr;
*xmlPtr = newPtr;
/* Cleanup */
xmlFreeDoc(docRes);
/* Return */
return;
}
void XmlDocument::putNode(XmlDocumentPtr *xmlPtr, const char *name, xmlNodePtr node)
{
XmlDocumentPtr curPtr;
curPtr = *xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
{
curPtr->curXml = node;
break;
}
curPtr = curPtr->nextPtr;
}
/* Return */
return;
}
void XmlDocument::putRootElementName(XmlDocumentPtr *xmlPtr, const char *name, char *root)
{
XmlDocumentPtr curPtr;
curPtr = *xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
{
if (curPtr->rootElementName != NULL)
delete curPtr->rootElementName;
curPtr->rootElementName = new char[strlen(root)+1];
strcpy(curPtr->rootElementName, root);
break;
}
curPtr = curPtr->nextPtr;
}
/* Return */
return;
}
void XmlDocument::putNavPath(XmlDocumentPtr *xmlPtr, const char *name, char *path)
{
XmlDocumentPtr curPtr;
curPtr = *xmlPtr;
/* Find out if buffer exists */
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
{
if (curPtr->navPath != NULL)
delete curPtr->navPath;
curPtr->navPath = new char[strlen(path)+1];
strcpy(curPtr->navPath, path);
break;
}
curPtr = curPtr->nextPtr;
}
/* Return */
return;
}
void XmlDocument::deleteDocument(XmlDocumentPtr *xmlPtr, const char *name)
{
XmlDocumentPtr curPtr, prevPtr;
curPtr = *xmlPtr;
prevPtr = NULL;
while (curPtr != NULL)
{
if (strcmp(curPtr->xmlName, name) == 0)
{
if (prevPtr == NULL)
*xmlPtr = curPtr->nextPtr;
else
prevPtr->nextPtr = curPtr->nextPtr;
delete curPtr;
break;
}
prevPtr = curPtr;
curPtr = curPtr->nextPtr;
}
}
void XmlDocument::deleteList(XmlDocumentPtr *xmlPtr)
{
XmlDocumentPtr tmpPtr;
while (*xmlPtr != NULL)
{
tmpPtr = *xmlPtr;
*xmlPtr = (*xmlPtr)->nextPtr;
delete tmpPtr;
}
}
void XmlDocument::printList(XmlDocumentPtr xmlPtr) const
{
XmlDocumentPtr curPtr;
curPtr = xmlPtr;
while (curPtr != NULL)
{
printf("Value %s\n", curPtr->xmlName);
curPtr = curPtr->nextPtr;
}
}