globle intBool MultifieldDOsEqual( DATA_OBJECT_PTR dobj1, DATA_OBJECT_PTR dobj2) { long extent1,extent2; /* 6.04 Bug Fix */ FIELD_PTR e1,e2; extent1 = GetpDOLength(dobj1); extent2 = GetpDOLength(dobj2); if (extent1 != extent2) { return(FALSE); } e1 = (FIELD_PTR) GetMFPtr(GetpValue(dobj1),GetpDOBegin(dobj1)); e2 = (FIELD_PTR) GetMFPtr(GetpValue(dobj2),GetpDOBegin(dobj2)); while (extent1 != 0) { if (e1->type != e2->type) { return(FALSE); } if (e1->value != e2->value) { return(FALSE); } extent1--; if (extent1 > 0) { e1++; e2++; } } return(TRUE); }
globle void *DOToMultifield( DATA_OBJECT *theValue) { struct multifield *dst, *src; if (theValue->type != MULTIFIELD) return(NULL); dst = (struct multifield *) CreateMultifield2(GetpDOLength(theValue)); src = (struct multifield *) theValue->value; GenCopyMemory(struct field,dst->multifieldLength, &(dst->theFields[0]),&(src->theFields[GetpDOBegin(theValue) - 1])); return((void *) dst); }
globle void SortFunction( void *theEnv, DATA_OBJECT_PTR returnValue) { long argumentCount, i, j, k = 0; DATA_OBJECT *theArguments, *theArguments2; DATA_OBJECT theArg; struct multifield *theMultifield, *tempMultifield; char *functionName; struct expr *functionReference; int argumentSize = 0; struct FunctionDefinition *fptr; #if DEFFUNCTION_CONSTRUCT DEFFUNCTION *dptr; #endif /*==================================*/ /* Set up the default return value. */ /*==================================*/ SetpType(returnValue,SYMBOL); SetpValue(returnValue,EnvFalseSymbol(theEnv)); /*=============================================*/ /* The function expects at least one argument. */ /*=============================================*/ if ((argumentCount = EnvArgCountCheck(theEnv,"sort",AT_LEAST,1)) == -1) { return; } /*=============================================*/ /* Verify that the comparison function exists. */ /*=============================================*/ if (EnvArgTypeCheck(theEnv,"sort",1,SYMBOL,&theArg) == FALSE) { return; } functionName = DOToString(theArg); functionReference = FunctionReferenceExpression(theEnv,functionName); if (functionReference == NULL) { ExpectedTypeError1(theEnv,"sort",1,"function name, deffunction name, or defgeneric name"); return; } /*======================================*/ /* For an external function, verify the */ /* correct number of arguments. */ /*======================================*/ if (functionReference->type == FCALL) { fptr = (struct FunctionDefinition *) functionReference->value; if ((GetMinimumArgs(fptr) > 2) || (GetMaximumArgs(fptr) == 0) || (GetMaximumArgs(fptr) == 1)) { ExpectedTypeError1(theEnv,"sort",1,"function name expecting two arguments"); ReturnExpression(theEnv,functionReference); return; } } /*=======================================*/ /* For a deffunction, verify the correct */ /* number of arguments. */ /*=======================================*/ #if DEFFUNCTION_CONSTRUCT if (functionReference->type == PCALL) { dptr = (DEFFUNCTION *) functionReference->value; if ((dptr->minNumberOfParameters > 2) || (dptr->maxNumberOfParameters == 0) || (dptr->maxNumberOfParameters == 1)) { ExpectedTypeError1(theEnv,"sort",1,"deffunction name expecting two arguments"); ReturnExpression(theEnv,functionReference); return; } } #endif /*=====================================*/ /* If there are no items to be sorted, */ /* then return an empty multifield. */ /*=====================================*/ if (argumentCount == 1) { EnvSetMultifieldErrorValue(theEnv,returnValue); ReturnExpression(theEnv,functionReference); return; } /*=====================================*/ /* Retrieve the arguments to be sorted */ /* and determine how many there are. */ /*=====================================*/ theArguments = (DATA_OBJECT *) genalloc(theEnv,(argumentCount - 1) * sizeof(DATA_OBJECT)); for (i = 2; i <= argumentCount; i++) { EnvRtnUnknown(theEnv,i,&theArguments[i-2]); if (GetType(theArguments[i-2]) == MULTIFIELD) { argumentSize += GetpDOLength(&theArguments[i-2]); } else { argumentSize++; } } if (argumentSize == 0) { genfree(theEnv,theArguments,(argumentCount - 1) * sizeof(DATA_OBJECT)); /* Bug Fix */ EnvSetMultifieldErrorValue(theEnv,returnValue); ReturnExpression(theEnv,functionReference); return; } /*====================================*/ /* Pack all of the items to be sorted */ /* into a data object array. */ /*====================================*/ theArguments2 = (DATA_OBJECT *) genalloc(theEnv,argumentSize * sizeof(DATA_OBJECT)); for (i = 2; i <= argumentCount; i++) { if (GetType(theArguments[i-2]) == MULTIFIELD) { tempMultifield = (struct multifield *) GetValue(theArguments[i-2]); for (j = GetDOBegin(theArguments[i-2]); j <= GetDOEnd(theArguments[i-2]); j++, k++) { SetType(theArguments2[k],GetMFType(tempMultifield,j)); SetValue(theArguments2[k],GetMFValue(tempMultifield,j)); } } else { SetType(theArguments2[k],GetType(theArguments[i-2])); SetValue(theArguments2[k],GetValue(theArguments[i-2])); k++; } } genfree(theEnv,theArguments,(argumentCount - 1) * sizeof(DATA_OBJECT)); functionReference->nextArg = SortFunctionData(theEnv)->SortComparisonFunction; SortFunctionData(theEnv)->SortComparisonFunction = functionReference; for (i = 0; i < argumentSize; i++) { ValueInstall(theEnv,&theArguments2[i]); } MergeSort(theEnv,(unsigned long) argumentSize,theArguments2,DefaultCompareSwapFunction); for (i = 0; i < argumentSize; i++) { ValueDeinstall(theEnv,&theArguments2[i]); } SortFunctionData(theEnv)->SortComparisonFunction = SortFunctionData(theEnv)->SortComparisonFunction->nextArg; functionReference->nextArg = NULL; ReturnExpression(theEnv,functionReference); theMultifield = (struct multifield *) EnvCreateMultifield(theEnv,(unsigned long) argumentSize); for (i = 0; i < argumentSize; i++) { SetMFType(theMultifield,i+1,GetType(theArguments2[i])); SetMFValue(theMultifield,i+1,GetValue(theArguments2[i])); } genfree(theEnv,theArguments2,argumentSize * sizeof(DATA_OBJECT)); SetpType(returnValue,MULTIFIELD); SetpDOBegin(returnValue,1); SetpDOEnd(returnValue,argumentSize); SetpValue(returnValue,(void *) theMultifield); }
void ClipsRuleMgr::getTemplateFields() { void *templatePtr; DATA_OBJECT theValue; void *theMultifield; DATA_OBJECT theValueOfType; void *theMultifieldOfType; int cnt1 = 0; int i = 1; int fieldType; void *fieldValue; m_templateItor = m_templateNames.begin(); while(m_templateItor!=m_templateNames.end()) { cout<<"Rule Engine IntializeStream::m_templateNames:" <<*m_templateItor<<endl; templatePtr = EnvFindDeftemplate(m_theEnv,(*m_templateItor).c_str()); EnvDeftemplateSlotNames(m_theEnv, templatePtr, &theValue); if (GetpType(&theValue) == MULTIFIELD) { cnt1 = GetpDOLength(&theValue); //theMultifield = theValue.value; theMultifield=GetValue(theValue); vector<Field> fields; for (i=1; i<=cnt1; i++) { fieldType = GetMFType(theMultifield,i); if (fieldType == SYMBOL) { Field tmp; fieldValue = (void*)ValueToString(GetMFValue(theMultifield,i)); tmp.name = string((char*)fieldValue); tmp.type = 2; EnvDeftemplateSlotTypes(m_theEnv,templatePtr,(char *)fieldValue, &theValueOfType); if (GetpType(&theValueOfType) == MULTIFIELD) { GetpDOLength(&theValueOfType); theMultifieldOfType = theValueOfType.value; ///default contraict to first one fieldType = GetMFType(theMultifieldOfType,1); if (fieldType == SYMBOL) { fieldValue = GetMFValue(theMultifieldOfType,1); if (string(ValueToString(fieldValue)) == string("FLOAT")) { tmp.type = 0; } else if (string(ValueToString(fieldValue)) == string("INTEGER")) { tmp.type = 1; } else { tmp.type = 2; } } else { cout<<"Rule Engine IntializeStream::EnvDeftemplateSlotTypes get unknown field type when get slot type:" <<fieldType<<endl; } } fields.push_back(tmp); } else { cout<<"Rule Engine IntializeStream::get unknown field type when get slot name:" <<fieldType<<endl; } } tableSchema.insert(pair<string, vector<Field> >(*m_templateItor, fields)); } else { cout<<"Rule Engine IntializeStream:::EnvDeftemplateSlotNames return not multifiled" <<endl; } m_templateItor++; } //call streaming interface to set tableSchema here }