DBInt DBTableFieldIsVisible(const DBObject *obj) {
DBObjTableField *tableField = (DBObjTableField *) obj;
switch (tableField->Type()) {
case DBTableFieldString:
case DBTableFieldInt:
case DBTableFieldFloat:
case DBTableFieldDate:
return (strlen(tableField->Format()) > 0 ? true : false);
default:
return (false);
}
}
DBInt RGlibGenFuncFieldCompare(DBObjTable *table, char *f0Text, char *f1Text, char *rText, DBInt diffMethod) {
DBInt intVal, ret, i, rowID;
DBFloat val[2];
DBObjTableField *field[2];
DBObjTableField *result;
DBObjRecord *record;
field[0] = table->Field(f0Text);
field[1] = table->Field(f1Text);
result = table->Field(rText);
if ((field[0] == (DBObjTableField *) NULL) || (field[1] == (DBObjTableField *) NULL)) {
CMmsgPrint(CMmsgAppError, "Invalid Compare Fields in: %s %d", __FILE__, __LINE__);
return (DBFault);
}
if (result == (DBObjTableField *) NULL)
table->AddField(result = new DBObjTableField(rText, DBTableFieldFloat, "%10.3f", sizeof(DBFloat4)));
if (diffMethod > 0) result->Format("%6.2f");
for (rowID = 0; rowID < table->ItemNum(); ++rowID) {
record = table->Item(rowID);
if ((record->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle)
result->Float(record, result->FloatNoData());
else {
for (i = 0; i < 2; ++i)
if (field[i]->Type() == DBTableFieldInt) {
intVal = field[i]->Int(record);
ret = intVal == field[i]->IntNoData();
val[i] = (DBFloat) intVal;
}
else {
val[i] = field[i]->Float(record);
ret = CMmathEqualValues(val[i], field[i]->FloatNoData());
}
if (ret) result->Float(record, result->FloatNoData());
else
switch (diffMethod) {
default:
result->Float(record, val[0] - val[1]);
break;
case 1:
result->Float(record, (val[0] - val[1]) * 100.0 / val[0]);
break;
case 2:
result->Float(record, (val[0] - val[1]) * 100.0 / (val[0] > val[1] ? val[0] : val[1]));
break;
}
}
}
return (DBSuccess);
}
DBInt RGlibGenFuncFieldCalculate (DBObjTable *table,char *f0Text,char *f1Text,char *rText,DBInt oper)
{
DBInt intVal, ret = false, i, rowID;
DBFloat val [2];
DBObjTableField *field [2];
DBObjTableField *result;
DBObjRecord *record;
field [0] = table->Field (f0Text);
field [1] = table->Field (f1Text);
result = table->Field (rText);
if ((field [0] == (DBObjTableField *) NULL) && (sscanf (f0Text,"%lf",val) != 1)) return (DBFault);
if ((field [1] == (DBObjTableField *) NULL) && (sscanf (f1Text,"%lf",val + 1) != 1)) return (DBFault);
if (result == (DBObjTableField *) NULL)
table->AddField (result = new DBObjTableField (rText,DBTableFieldFloat,"%10.3f",sizeof (DBFloat4)));
if (field [0] != (DBObjTableField *) NULL)
result->Format (field [0]->Format ());
else if (field [1] != (DBObjTableField *) NULL)
result->Format (field [1]->Format ());
for (rowID = 0;rowID < table->ItemNum ();++rowID)
{
record = table->Item (rowID);
if ((record->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle)
result->Float (record,result->FloatNoData ());
else
{
for (i = 0;i < 2;++i)
if (field [i] != (DBObjTableField *) NULL)
{
ret = false;
if (field [i]->Type () == DBTableFieldInt)
{
intVal = field [i]->Int (record);
val [i] = (DBFloat) intVal;
ret = intVal == field [i]->IntNoData ();
}
else
{
val [i] = field [i]->Float (record);
ret = CMmathEqualValues (val [i],field [i]->FloatNoData ());
}
if (ret)
{
result->Float (record,result->FloatNoData ());
goto Continue;
}
}
if ((oper == DBMathOperatorDiv) && (val [1] == 0))
result->Float (record,result->FloatNoData ());
else
switch (oper)
{
case DBMathOperatorAdd: result->Float (record, val [0] + val [1]); break;
case DBMathOperatorSub: result->Float (record, val [0] - val [1]); break;
case DBMathOperatorMul: result->Float (record, val [0] * val [1]); break;
case DBMathOperatorDiv: result->Float (record, val [0] / val [1]); break;
default: CMmsgPrint (CMmsgAppError, "Invalid Operand in: %s %d",__FILE__,__LINE__); break;
}
Continue:
continue;
}
}
return (DBSuccess);
}
UIAttribView::UIAttribView (DBObjData *data) : DBObject (data->Name (),sizeof (UIAttribView))
{
DBObjTableField *field;
DBObjectLIST<DBObjTableField> *fields;
Widget mainForm, scrolledW, rowCol, label;
XmString string;
Atom deleteWindowAtom = XmInternAtom(XtDisplay(UITopLevel ()),(char *) "WM_DELETE_WINDOW",FALSE);
DataPTR = data;
ItemTable = DataPTR->Table (DBrNItems);
Name (UIAttribViewSTR);
DShellWGT = XtVaCreatePopupShell ("UIAttribView",xmDialogShellWidgetClass,UITopLevel (),
XmNkeyboardFocusPolicy, XmPOINTER,
XmNtitle, data->Name (),
XmNtransient, False,
XmNminWidth, 400,
XmNminHeight, 300,
NULL);
XmAddWMProtocolCallback (DShellWGT,deleteWindowAtom,(XtCallbackProc) _UIAttribViewDeleteCBK,(XtPointer) this);
mainForm = XtVaCreateWidget ("UIAttribViewForm",xmFormWidgetClass,DShellWGT,
XmNshadowThickness, 0,
NULL);
string = XmStringCreate ((char *) "Item:",UICharSetBold);
label = XtVaCreateManagedWidget ("UIAttribViewNameLabel",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNlabelString, string,
XmNrecomputeSize, False,
NULL);
XmStringFree (string);
string = XmStringCreate ((char *) "",UICharSetNormal);
ItemNameWGT = XtVaCreateManagedWidget ("UIAttribViewNameText",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNleftOffset, 5,
XmNlabelString, string,
NULL);
XmStringFree (string);
scrolledW = XtVaCreateManagedWidget ("UIAttribViewScrolledW",xmScrolledWindowWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, label,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
XmNheight, 150,
XmNvisualPolicy, XmCONSTANT,
XmNscrollingPolicy, XmAUTOMATIC,
NULL);
rowCol = XtVaCreateManagedWidget ("UIAttribViewRowColumn",xmRowColumnWidgetClass,scrolledW,
XmNnumColumns, 2,
XmNorientation, XmHORIZONTAL,
XmNrowColumnType, XmWORK_AREA,
NULL);
NamesRowCol = XtVaCreateManagedWidget ("UIAttribViewNamesRowColumn",xmRowColumnWidgetClass,rowCol,
XmNorientation, XmVERTICAL,
XmNrowColumnType, XmWORK_AREA,
XmNpacking, XmPACK_COLUMN,
XmNspacing, 0,
NULL);
FieldsRowCol = XtVaCreateManagedWidget ("UIAttribViewNamesRowColumn",xmRowColumnWidgetClass,rowCol,
XmNorientation, XmVERTICAL,
XmNrowColumnType, XmWORK_AREA,
XmNspacing, 0,
NULL);
switch (DataPTR->Type ())
{
case DBTypeVectorPoint:
case DBTypeVectorLine:
case DBTypeVectorPolygon:
case DBTypeGridDiscrete:
fields = ItemTable->Fields ();
for (field = fields->First ();field != (DBObjTableField *) NULL;field = fields->Next ())
if (DBTableFieldIsVisible (field) == true) NewField (field->Name (),field->Format ());
break;
case DBTypeGridContinuous:
{
DBObjRecord *record;
DBGridIF *gridIF = new DBGridIF (DataPTR);
ItemTable = DataPTR->Table (DBrNLayers);
for (record = ItemTable->First ();record != (DBObjRecord *) NULL;record = ItemTable->Next ())
NewField (record->Name (),gridIF->ValueFormat ());
delete gridIF;
} break;
case DBTypeNetwork:
{
DBObjTable *cellTable = DataPTR->Table (DBrNCells);
NewField ((char *) "Basin Name",(char *) "%s");
fields = ItemTable->Fields ();
for (field = fields->First ();field != (DBObjTableField *) NULL;field = fields->Next ())
if (DBTableFieldIsVisible (field) == true) NewField (field->Name (),field->Format ());
fields = cellTable->Fields ();
for (field = fields->First ();field != (DBObjTableField *) NULL;field = fields->Next ())
if (DBTableFieldIsVisible (field) == true) NewField (field->Name (),field->Format ());
} break;
default: break;
}
XtManageChild (mainForm);
UILoop ();
}
DBInt RGlibPointInterStationTS(DBObjData *pntData, DBObjData *tsData, char *relateFldName, char *joinFldName) {
DBInt first = true, tsIndex, tsRowNum = 0;
DBObjTable *pntTBL = pntData->Table(DBrNItems), *tsTBL;
DBObjectLIST<DBObjTableField> *fields;
DBObjTableField *pntNextFLD = pntTBL->Field(RGlibNextStation);
DBObjTableField *pntAreaFLD = pntTBL->Field(RGlibArea);
DBObjTableField *pntInterStnFLD = pntTBL->Field(RGlibInterStation);
DBObjTableField *pntRelateFLD;
DBObjTableField *pntNewNextFLD;
DBObjTableField *pntNewInterStnFLD;
DBObjTableField *tsTimeFLD;
DBObjTableField *tsJoinFLD;
DBObjTableField *tsNextStnFLD, *tsInterStnFLD;
DBObjRecord *pntRec, *nextPntRec, *tsRec, *tsIndexRec;
DBDate curDate, date;
if (pntNextFLD == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "Missing Next Station Field!");
return (DBFault);
}
if (pntAreaFLD == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "Missing STN Area Field!");
return (DBFault);
}
if (pntInterStnFLD == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "Missing Interfluvial Area Field!");
return (DBFault);
}
tsTBL = tsData->Table(DBrNItems);
tsNextStnFLD = new DBObjTableField(RGlibNextStation, DBTableFieldInt, "%8d", sizeof(DBInt));
tsTBL->AddField(tsNextStnFLD);
tsInterStnFLD = new DBObjTableField(RGlibInterStation, DBTableFieldFloat, "%9.1f", sizeof(DBFloat4));
tsTBL->AddField(tsInterStnFLD);
fields = tsTBL->Fields();
for (tsTimeFLD = fields->First(); tsTimeFLD != (DBObjTableField *) NULL; tsTimeFLD = fields->Next())
if (tsTimeFLD->Type() == DBTableFieldDate) break;
if (tsTimeFLD == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "Missing Date Field!");
return (DBFault);
}
if ((tsJoinFLD = tsTBL->Field(joinFldName)) == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "Missing Join Field!");
return (DBFault);
}
fields = new DBObjectLIST<DBObjTableField>("Field List");
fields->Add(new DBObjTableField(*tsTimeFLD));
fields->Add(new DBObjTableField(*tsJoinFLD));
tsTBL->ListSort(fields);
delete fields;
pntTBL = new DBObjTable(*pntTBL);
pntNextFLD = pntTBL->Field(RGlibNextStation);
pntAreaFLD = pntTBL->Field(RGlibArea);
pntInterStnFLD = pntTBL->Field(RGlibInterStation);
pntNewNextFLD = new DBObjTableField("NextStnTS", pntNextFLD->Type(), pntNextFLD->Format(), pntNextFLD->Length());
pntNewInterStnFLD = new DBObjTableField("InterFluTS", pntInterStnFLD->Type(), pntInterStnFLD->Format(),
pntInterStnFLD->Length());
pntRelateFLD = pntTBL->Field(relateFldName);
pntTBL->AddField(pntNewNextFLD);
pntTBL->AddField(pntNewInterStnFLD);
pntTBL->ListSort(pntRelateFLD);
tsIndexRec = tsTBL->First(&tsIndex);
for (tsRec = tsTBL->First(); tsRec != (DBObjRecord *) NULL; tsRec = tsTBL->Next()) {
DBPause(tsRowNum++ * 100 / tsTBL->ItemNum());
date = tsTimeFLD->Date(tsRec);
if (date != curDate) {
if (first) first = false;
else {
for (pntRec = pntTBL->First(); pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) {
if ((pntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked) continue;
for (nextPntRec = pntTBL->Item(pntNextFLD->Int(pntRec) - 1);
(nextPntRec != (DBObjRecord *) NULL) &&
((nextPntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked);
nextPntRec = pntTBL->Item(pntNextFLD->Int(nextPntRec) - 1));
if (nextPntRec != (DBObjRecord *) NULL) {
pntNewNextFLD->Int(pntRec, nextPntRec->RowID() + 1);
pntNewInterStnFLD->Float(nextPntRec,
pntNewInterStnFLD->Float(nextPntRec) - pntAreaFLD->Float(pntRec));
}
}
pntRec = pntTBL->First();
for (; tsIndexRec != (DBObjRecord *) NULL; tsIndexRec = tsTBL->Next(&tsIndex)) {
if (tsRec == tsIndexRec) break;
for (; pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next())
if (pntRelateFLD->Int(pntRec) == tsJoinFLD->Int(tsIndexRec)) {
tsNextStnFLD->Int(tsIndexRec, pntNewNextFLD->Int(pntRec));
tsInterStnFLD->Float(tsIndexRec, pntNewInterStnFLD->Float(pntRec));
break;
}
if (pntRec == (DBObjRecord *) NULL) pntRec = pntTBL->First();
}
}
for (pntRec = pntTBL->First(); pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) {
pntNewNextFLD->Int(pntRec, 0);
pntNewInterStnFLD->Float(pntRec, pntAreaFLD->Float(pntRec));
pntRec->Flags(DBObjectFlagLocked, DBClear);
}
curDate = date;
pntRec = pntTBL->First();
}
for (; pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next())
if (pntRelateFLD->Int(pntRec) == tsJoinFLD->Int(tsRec)) {
pntRec->Flags(DBObjectFlagLocked, DBSet);
break;
}
if (pntRec == (DBObjRecord *) NULL) pntRec = pntTBL->First();
}
if (!first) {
for (pntRec = pntTBL->First(); pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) {
if ((pntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked) continue;
for (nextPntRec = pntTBL->Item(pntNextFLD->Int(pntRec) - 1);
(nextPntRec != (DBObjRecord *) NULL) &&
((nextPntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked);
nextPntRec = pntTBL->Item(pntNextFLD->Int(nextPntRec) - 1));
if (nextPntRec != (DBObjRecord *) NULL) {
pntNewNextFLD->Int(pntRec, nextPntRec->RowID() + 1);
pntNewInterStnFLD->Float(nextPntRec, pntNewInterStnFLD->Float(nextPntRec) - pntAreaFLD->Float(pntRec));
}
}
pntRec = pntTBL->First();
for (; tsIndexRec != (DBObjRecord *) NULL; tsIndexRec = tsTBL->Next(&tsIndex)) {
if (tsRec == tsIndexRec) break;
for (; pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next())
if (pntRelateFLD->Int(pntRec) == tsJoinFLD->Int(tsIndexRec)) {
tsNextStnFLD->Int(tsIndexRec, pntNewNextFLD->Int(pntRec));
tsInterStnFLD->Float(tsIndexRec, pntNewInterStnFLD->Float(pntRec));
break;
}
if (pntRec == (DBObjRecord *) NULL) pntRec = pntTBL->First();
}
}
delete pntTBL;
return (DBSuccess);
}
int main (int argc,char *argv [])
{
int argPos, argNum = argc, numGrpNames = 0, i = 0;
char **groupnames, *rename = (char *) NULL, *tableName = (char *) NULL;
bool ascii = false;
FieldOptions *head = (FieldOptions *) NULL, *p = (FieldOptions *) NULL, *temp = (FieldOptions *) NULL;
Groups **groups = (Groups **) NULL;
FILE *outFile = (FILE *) NULL;
DBObjData *inData, *outData;
DBObjTable *inTable, *outTable;
DBObjTableField *field;
DBObjRecord *inRecord, *outRecord;
DBObjectLIST<DBObjTableField> *fields;
if(argc <= 2) { doHelp(false,argv[0]); return(DBSuccess); }
outData = new DBObjData("Untitled", DBTypeTable);
outTable = outData->Table(DBrNItems);
head = new FieldOptions(BAD,"","", (FieldOptions *) NULL);
groupnames = (char **) malloc(sizeof(char *));
for (argPos = 1;argPos < argNum;)
{
if (CMargTest(argv[argPos],"-f","--field"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing operation and field after -f!"); return (CMfailed); }
if(!strcmp(argv[argPos],"pct"))
{
if (argNum <= argPos + 2)
{ CMmsgPrint (CMmsgUsrError,"Missing field and/or percentage after -f pct!"); return (CMfailed); }
p = FOHierarchy(argv[argPos],argv[argPos+1],rename,atoi(argv[argPos+2]),head);
argNum = CMargShiftLeft(argPos,argv,argNum);
argNum = CMargShiftLeft(argPos,argv,argNum);
}
else if(!strcmp(argv[argPos],"num"))
{
char *num = new char[4];
strcpy(num,"Num");
p = FOHierarchy(argv[argPos],num,rename,-1,head);
}
else
{
if (argNum < argPos + 1)
{ CMmsgPrint (CMmsgUsrError,"Missing operation or field after -f %s!",argv[argPos]); return (CMfailed); }
p = FOHierarchy(argv[argPos],argv[argPos+1],rename,-1,head);
argNum = CMargShiftLeft(argPos,argv,argNum);
}
p->setPrint(true);
rename = (char *) NULL;
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-g","--group"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing groupname!"); return (CMfailed); }
if((groupnames = (char **) realloc(groupnames,(numGrpNames + 1) * sizeof(char *))) == (char **) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return(DBFault); }
groupnames[numGrpNames] = argv[argPos];
numGrpNames++;
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-h","--help"))
{
argNum = CMargShiftLeft (argPos,argv,argNum);
if(CMargTest(argv[argPos],"e","extend"))
{
doHelp(true,argv[0]);
argNum = CMargShiftLeft (argPos,argv,argNum);
}
else doHelp(false,argv[0]);
}
if (CMargTest(argv[argPos],"-c","--ascii"))
{
ascii = true;
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-a","--table"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing table name!"); return (CMfailed); }
tableName = argv[argPos];
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-r","--rename"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing field after -r!"); return (CMfailed); }
rename = argv[argPos];
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-o","--output"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing output filename!"); return (CMfailed); }
if((outFile = fopen(argv[argPos],"w")) == (FILE *) NULL)
{ CMmsgPrint (CMmsgUsrError,"Cannot open file %s",argv[argPos]); return (CMfailed); }
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-t","--title"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing title!"); return (CMfailed); }
outData->Name(argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-s","--subject"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing subject!"); return (CMfailed); }
outData->Document(DBDocSubject,argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-d","--domain"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing domain!"); return (CMfailed); }
outData->Document(DBDocGeoDomain,argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-v","--version"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing version!"); return (CMfailed); }
outData->Document(DBDocVersion,argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if ((argv[argPos][0] == '-') && (strlen (argv[argPos]) > 1))
{ CMmsgPrint (CMmsgUsrError, "Unknown option: %s!",argv[argPos]); return (CMfailed); }
argPos++;
}
if(outFile == (FILE *) NULL) outFile = stdout;
if(head->next == (FieldOptions *) NULL) return(DBSuccess);
inData = new DBObjData();
if ((argNum > 1) && (strcmp(argv[1],"-") != 0)) inData->Read(argv[1]);
else inData->Read(stdin);
if (outData->Name() == (char *) NULL) outData->Name("Untitled");
if (outData->Document(DBDocSubject) == (char *) NULL) outData->Document(DBDocSubject,inData->Document(DBDocSubject));
if (outData->Document(DBDocGeoDomain) == (char *) NULL) outData->Document(DBDocGeoDomain,inData->Document(DBDocGeoDomain));
if (outData->Document(DBDocVersion) == (char *) NULL) outData->Document(DBDocVersion,inData->Document(DBDocVersion));
if(tableName == (char *) NULL) tableName = DBrNItems;
if((inTable = inData->Table(tableName)) == (DBObjTable *) NULL)
{ CMmsgPrint (CMmsgUsrError,"Invalid table!"); delete inData; return (CMfailed); }
if((groups = (Groups **) malloc(numGrpNames * sizeof(Groups *))) == (Groups **) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return(DBFault); }
for(i = 0; i < numGrpNames; i++)
{
if((field = inTable->Field(groupnames[i])) == (DBObjTableField *) NULL)
{ CMmsgPrint (CMmsgUsrError, "Invalid group name: %s",groupnames[i]); return (CMfailed); }
if(DBTableFieldIsCategory(field))
{
groups[i] = new Groups();
groups[i]->srcFLD = field;
groups[i]->dstFLD = new DBObjTableField(*field);
outTable->AddField(groups[i]->dstFLD);
// CMmsgPrint (CMmsgUsrError, "Added Group: %s",groups[i]->dstFLD->Name());
}
else CMmsgPrint (CMmsgUsrError, "Group %s is not Category!",groupnames[i]);
}
delete groupnames;
p = head->next;
temp = head;
while(p->next)
{
FieldOptions *duplicate = (FieldOptions *) NULL, *prev = p;
if(!p->getPrint() && FLDExists(p,p->getOldName(),p->getFunc(),&duplicate))
{ temp->next = p->next; delete p; p = temp->next; continue; }
while(FLDExists(prev,prev->getOldName(),prev->getFunc(),&prev,&duplicate) && !duplicate->getPrint())
{ prev->next = duplicate->next; delete duplicate; }
temp = p;
p = p->next;
}
// p = head->next;
// while(p) { CMmsgPrint (CMmsgUsrError, "Added: o:%s n:%s p:",p->getOldName(),p->getNewName()); if(p->getPrint()) CMmsgPrint (CMmsgUsrError, "true"); else CMmsgPrint (CMmsgUsrError, "false"); p = p->next; }
fields = inTable->Fields();
p = head->next;
while(p)
{
field = fields->Item (p->getOldName());
if (p->getFunc() == MIN || p->getFunc() == MAX)
p->field = new DBObjTableField(p->getNewName(),field->Type(),field->Format(),field->Length());
else if(p->getFunc() == NUM || p->getFunc() == NONNULL)
p->field = new DBObjTableField(p->getNewName(), DBTableFieldInt, DBHiddenField, sizeof (DBInt));
else p->field = new DBObjTableField(p->getNewName(), DBTableFieldFloat, DBHiddenField, sizeof(DBFloat));
if(p->getFunc() != NUM && p->getFunc() != NONNULL)
{
// if ((field = inTable->Field(p->getOldName())) == (DBObjTableField *) NULL)
if (field == (DBObjTableField *) NULL)
{
CMmsgPrint (CMmsgUsrError, "Invalid field name: %s",p->getOldName());
return(DBFault);
}
if (!DBTableFieldIsNumeric(field))
{
CMmsgPrint (CMmsgUsrError, "Field is not Numeric: %s",p->getOldName());
return(DBFault);
}
}
outTable->AddField(p->field);
p = p->next;
}
// MAKE SURE TO TEST FOR SPEED BY DECLARING INTS OUTSIDE OF FOR LOOPS!!!
for (int inRecID = 0;inRecID < inTable->ItemNum();++inRecID)
{
inRecord = inTable->Item(inRecID);
if ((outRecord = FindMatch(inRecord, outTable,(const Groups**) groups, numGrpNames)) != (DBObjRecord *) NULL)
{
p = head->next;
while(p)
{
field = fields->Item (p->getOldName());
switch(p->getFunc())
{
default:
break;
case NUM:
p->field->Int(outRecord,p->field->Int(outRecord) + 1);
break;
case NONNULL:
if (p->isInt())
{
if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,p->field->Int(outRecord) + 1);
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Int(outRecord,p->field->Int(outRecord) + 1);
}
break;
case MIN:
if (p->isInt())
{
if(field->Int(inRecord) != field->IntNoData())
{
if (p->field->Int(outRecord) != p->field->IntNoData())
{ if (field->Int(inRecord) < p->field->Int(outRecord)) p->field->Int(outRecord,field->Int(inRecord)); }
else { p->field->Int(outRecord,field->Int(inRecord)); }
}
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
{
if (!CMmathEqualValues(p->field->Float(inRecord),p->field->FloatNoData()))
{ if (field->Float(inRecord) < p->field->Float(outRecord)) p->field->Float(outRecord,field->Float(inRecord)); }
else { p->field->Float(outRecord,field->Float(inRecord)); }
}
}
break;
case MAX:
if (p->isInt())
{
if(field->Int(inRecord) != field->IntNoData())
{
if (p->field->Int(outRecord) != p->field->IntNoData())
{ if (field->Int(inRecord) > p->field->Int(outRecord)) p->field->Int(outRecord,field->Int(inRecord)); }
else { p->field->Int(outRecord,field->Int(inRecord)); }
}
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
{
if (!CMmathEqualValues(p->field->Float(inRecord),p->field->FloatNoData()))
{ if (field->Float(inRecord) > p->field->Float(outRecord)) p->field->Float(outRecord,field->Float(inRecord)); }
else { p->field->Float(outRecord,field->Float(inRecord)); }
}
}
break;
case SUM:
if (p->isInt())
{
if(field->Int(inRecord) != field->IntNoData())
p->field->Int(outRecord,p->field->Int(outRecord) + field->Int(inRecord));
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Float(outRecord,p->field->Float(outRecord) + field->Float(inRecord));
}
break;
case DEV:
case PCT:
case MED:
p->tailVal = p->tailVal->next = new Values();
p->tailVal->val = field->Float(inRecord);
p->tailVal->next = 0;
break;
case MOD:
Values *cur = p->getHead();
while(cur->next && !CMmathEqualValues(cur->val,field->Float(inRecord))) cur = cur->next;
if(cur->next) cur->occur++;
else
{
p->tailVal->val = field->Float(inRecord);
p->tailVal->occur = 1;
p->tailVal = p->tailVal->next = new Values();
}
break;
}
p = p->next;
}
}
else
{
outRecord = outTable->Add();
for(i = 0; i < numGrpNames; i++)
{
switch (groups[i]->srcFLD->Type())
{
default:
case DBTableFieldString:
groups[i]->dstFLD->String(outRecord,groups[i]->srcFLD->String(inRecord));
break;
case DBTableFieldInt:
groups[i]->dstFLD->Int(outRecord,groups[i]->srcFLD->Int(inRecord));
break;
}
}
p = head->next;
while(p)
{
field = fields->Item (p->getOldName());
switch(p->getFunc())
{
default:
case BAD:
break;
case NUM:
p->setInt();
p->field->Int(outRecord,1);
break;
case NONNULL:
if (field->Type() == DBTableFieldInt)
{
p->setInt();
if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,1);
else p->field->Int(outRecord,0);
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData())) p->field->Int(outRecord,1);
else p->field->Int(outRecord,0);
}
break;
case MIN:
if (field->Type() == DBTableFieldInt)
{ p->setInt(); if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,field->Int(inRecord)); }
else
{
if(!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Float(outRecord,field->Float(inRecord));
}
break;
case MAX:
if (field->Type() == DBTableFieldInt)
{ p->setInt(); if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,field->Int(inRecord)); }
else
{
if(!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Float(outRecord,field->Float(inRecord));
}
break;
case SUM:
if (field->Type() == DBTableFieldInt)
{
p->setInt();
if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,field->Int(inRecord));
else p->field->Int(outRecord,0);
}
else
{
if(!CMmathEqualValues(field->Float(inRecord),field->FloatNoData())) p->field->Float(outRecord,field->Float(inRecord));
else p->field->Float(outRecord,0.0);
}
break;
case DEV:
case PCT:
case MED:
p->tailVal = p->tailVal->next = new Values();
p->tailVal->val = field->Float(inRecord);
p->tailVal->next = 0;
break;
case MOD:
p->tailVal->val = field->Float(inRecord);
p->tailVal->occur = 1;
p->tailVal = p->tailVal->next = new Values();
break;
}
p = p->next;
}
}
}
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
outRecord = outTable->Item(outRecID);
p = head->next;
FieldOptions *sum, *num;
DBFloat mod;
int occurrance;
float i;
bool mult;
Values *cur;
while(p)
{
field = fields->Item (p->getOldName());
switch(p->getFunc())
{
case AVG:
if((FLDExists(head,p->getOldName(),SUM,&sum)) && (FLDExists(head,p->getOldName(),NONNULL,&num)))
p->field->Float(outRecord,sum->field->Float(outRecord) / (DBFloat) (num->field->Int(outRecord)));
else CMmsgPrint (CMmsgUsrError, "Program Error! Could not find SUM or NONNULL in linked list! Please contact the GHAAS developers group!");
break;
case NAVG:
if((FLDExists(head,p->getOldName(),SUM,&sum)) && (FLDExists(head,"NUM",NUM,&num)))
p->field->Float(outRecord,sum->field->Float(outRecord) / (DBFloat) (num->field->Int(outRecord)));
else CMmsgPrint (CMmsgUsrError, "Program Error! Could not find SUM or NUM in linked list! Please contact the GHAAS developers group!");
break;
case PCT:
case MED:
i = (float) (inTable->ItemNum() * p->getHead()->occur * 0.01) - 1;
cur = p->getHead()->next;
while(i > 0) { cur = cur->next; i--; }
p->field->Float(outRecord,(cur->val + cur->next->val) / 2);
break;
case MOD:
mod = 0.0;
occurrance = 0;
mult = false;
cur = p->getHead();
while(cur)
{
if(cur->occur > occurrance)
{
mod = cur->val;
occurrance = cur->occur;
mult = false;
}
else if(cur->occur == occurrance) mult = true;
cur = cur->next;
}
if(mult) CMmsgPrint (CMmsgUsrError, "** Warning, multiple answers for MOD, listing first found!");
p->field->Float(outRecord,mod);
break;
default:
break;
}
p = p->next;
}
}
p = head->next;
while(p)
{
if(p->getFunc() == DEV)
{
FieldOptions *avg, *num;
field = fields->Item (p->getOldName());
if((FLDExists(head,p->getOldName(),AVG,&avg)) && (FLDExists(head,"NUM",NUM,&num)))
{
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
outRecord = outTable->Item(outRecID);
DBFloat sum = 0.0;
Values *cur = p->getHead()->next;
while(cur)
{
// sum += (DBFloat) (pow((cur->val - avg->field->Float(outRecord)),2));
DBFloat add = (cur->val - avg->field->Float(outRecord));
sum += (DBFloat) (add * add);
cur = cur->next;
}
sum = sqrt(sum /(DBFloat) num->field->Int(outRecord));
p->field->Float(outRecord,sum);
}
}
else CMmsgPrint (CMmsgUsrError, "Program Error! Could not find AVG or NUM in linked list! Please contact the GHAAS developers group!");
}
p = p->next;
}
// DELETE unnecessary fields which were for temp storage
fields = outTable->Fields();
p = head->next;
while(p)
{
if(!p->getPrint()) outTable->DeleteField(fields->Item(p->getNewName()));
p = p->next;
}
p = head->next;
while(p)
{
if ((strcmp(p->field->Format(),DBHiddenField) == 0) && p->getPrint())
{
if(p->isInt())
{
int maxval = 0;
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
int val = p->field->Int(outTable->Item(outRecID));
if (maxval < val) maxval = val; else if (maxval < -val) maxval = -val;
}
p->field->Format(DBMathIntAutoFormat(maxval));
}
else
{
float maxval = 0.0;
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
float val = p->field->Float(outTable->Item(outRecID));
if (maxval < val) maxval = val; else if (maxval < -val) maxval = -val;
}
p->field->Format(DBMathFloatAutoFormat(maxval));
}
}
// CMmsgPrint (CMmsgUsrError, "Format(%s)%d,%d: '%s'",p->getFuncName(),p->isInt(),p->getPrint(),p->field->Format());
p = p->next;
}
DBObjectLIST<DBObjTableField> *list = new DBObjectLIST<DBObjTableField> ("Sorted Field List");
for(i = 0; i < numGrpNames; i++) list->Add(groups[i]->dstFLD);
outTable->ListSort(list);
if (ascii) DBExportASCIITable(outTable,outFile); else outData->Write(outFile);
/* CLEANUP ************************************************/
if(outFile != stdout) fclose(outFile);
for(i = 0; i < numGrpNames; i++) delete groups[i]->dstFLD;
delete groups;
p = head;
while(p)
{
head = head->next;
delete p;
p = head;
}
return(DBSuccess);
}