globle void ShowFactPatternNetwork(
void *theEnv)
{
struct factPatternNode *patternPtr;
struct deftemplate *theDeftemplate;
const char *theName;
int depth = 0, i;
theName = GetConstructName(theEnv,"show-fpn","template name");
if (theName == NULL) return;
theDeftemplate = (struct deftemplate *) EnvFindDeftemplate(theEnv,theName);
if (theDeftemplate == NULL) return;
patternPtr = theDeftemplate->patternNetwork;
while (patternPtr != NULL)
{
for (i = 0; i < depth; i++) EnvPrintRouter(theEnv,WDISPLAY," ");
if (patternPtr->header.singlefieldNode) EnvPrintRouter(theEnv,WDISPLAY,"SF ");
else if (patternPtr->header.multifieldNode)
{
EnvPrintRouter(theEnv,WDISPLAY,"MF");
if (patternPtr->header.endSlot) EnvPrintRouter(theEnv,WDISPLAY,")");
else EnvPrintRouter(theEnv,WDISPLAY,"*");
PrintLongInteger(theEnv,WDISPLAY,(long long) patternPtr->leaveFields);
EnvPrintRouter(theEnv,WDISPLAY," ");
}
EnvPrintRouter(theEnv,WDISPLAY,"Slot: ");
PrintLongInteger(theEnv,WDISPLAY,(long long) patternPtr->whichSlot);
EnvPrintRouter(theEnv,WDISPLAY," Field: ");
PrintLongInteger(theEnv,WDISPLAY,(long long) patternPtr->whichField);
EnvPrintRouter(theEnv,WDISPLAY," Expression: ");
if (patternPtr->networkTest == NULL) EnvPrintRouter(theEnv,WDISPLAY,"None");
else PrintExpression(theEnv,WDISPLAY,patternPtr->networkTest);
EnvPrintRouter(theEnv,WDISPLAY," RightHash: ");
if (patternPtr->header.rightHash == NULL) EnvPrintRouter(theEnv,WDISPLAY,"None");
else PrintExpression(theEnv,WDISPLAY,patternPtr->header.rightHash);
EnvPrintRouter(theEnv,WDISPLAY,"\n");
if (patternPtr->nextLevel == NULL)
{
while (patternPtr->rightNode == NULL)
{
patternPtr = patternPtr->lastLevel;
depth--;
if (patternPtr == NULL) return;
}
patternPtr = patternPtr->rightNode;
}
else
{
patternPtr = patternPtr->nextLevel;
depth++;
}
}
}
static void ClearDeffacts(
void *theEnv)
{
#if (! RUN_TIME) && (! BLOAD_ONLY)
struct expr *stub;
struct deffacts *newDeffacts;
/*=====================================*/
/* Create the data structures for the */
/* expression (assert (initial-fact)). */
/*=====================================*/
stub = GenConstant(theEnv,FCALL,FindFunction(theEnv,"assert"));
stub->argList = GenConstant(theEnv,DEFTEMPLATE_PTR,EnvFindDeftemplate(theEnv,"initial-fact"));
ExpressionInstall(theEnv,stub);
/*=============================================*/
/* Create a deffacts data structure to contain */
/* the expression and initialize it. */
/*=============================================*/
newDeffacts = get_struct(theEnv,deffacts);
newDeffacts->header.whichModule =
(struct defmoduleItemHeader *) GetDeffactsModuleItem(theEnv,NULL);
newDeffacts->header.name = (SYMBOL_HN *) EnvAddSymbol(theEnv,"initial-fact");
IncrementSymbolCount(newDeffacts->header.name);
newDeffacts->assertList = PackExpression(theEnv,stub);
newDeffacts->header.next = NULL;
newDeffacts->header.ppForm = NULL;
newDeffacts->header.usrData = NULL;
ReturnExpression(theEnv,stub);
/*===========================================*/
/* Store the deffacts in the current module. */
/*===========================================*/
AddConstructToModule(&newDeffacts->header);
#else
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(theEnv)
#endif
#endif
}
void *entryPoint(void * m_theEnv)
{
void *newFact;
void *templatePtr;
void *theMultifield;
DATA_OBJECT theValue;
char *templatename = "InputSource";
/* Create the fact. */
/*==================*/
templatePtr = EnvFindDeftemplate(m_theEnv,templatename);
newFact = EnvCreateFact(m_theEnv,templatePtr);
if (newFact == NULL) return 0;
theValue.type = INTEGER;
theValue.value = EnvAddLong(m_theEnv,100);
EnvPutFactSlot(m_theEnv,newFact,"speed",&theValue);
theValue.type = FLOAT;
theValue.value = EnvAddDouble(m_theEnv,1.0);
EnvPutFactSlot(m_theEnv,newFact,"astatus",&theValue);
theValue.type = INTEGER;
theValue.value = EnvAddLong(m_theEnv,2);
EnvPutFactSlot(m_theEnv,newFact,"rclass",&theValue);
theValue.type = INTEGER;
theValue.value = EnvAddLong(m_theEnv,10000);
EnvPutFactSlot(m_theEnv,newFact,"distance",&theValue);
EnvAssignFactSlotDefaults(m_theEnv,newFact);
EnvAssert(m_theEnv,newFact);
return newFact;
}
static DATA_OBJECT_PTR GetSaveFactsDeftemplateNames(
void *theEnv,
struct expr *theList,
int saveCode,
int *count,
int *error)
{
struct expr *tempList;
DATA_OBJECT_PTR theDOArray;
int i, tempCount;
struct deftemplate *theDeftemplate = NULL;
/*=============================*/
/* Initialize the error state. */
/*=============================*/
*error = FALSE;
/*=====================================================*/
/* If no deftemplate names were specified as arguments */
/* then the deftemplate name list is empty. */
/*=====================================================*/
if (theList == NULL)
{
*count = 0;
return(NULL);
}
/*======================================*/
/* Determine the number of deftemplate */
/* names to be stored in the name list. */
/*======================================*/
for (tempList = theList, *count = 0;
tempList != NULL;
tempList = tempList->nextArg, (*count)++)
{ /* Do Nothing */ }
/*=========================================*/
/* Allocate the storage for the name list. */
/*=========================================*/
theDOArray = (DATA_OBJECT_PTR) gm3(theEnv,(long) sizeof(DATA_OBJECT) * *count);
/*=====================================*/
/* Loop through each of the arguments. */
/*=====================================*/
for (tempList = theList, i = 0;
i < *count;
tempList = tempList->nextArg, i++)
{
/*========================*/
/* Evaluate the argument. */
/*========================*/
EvaluateExpression(theEnv,tempList,&theDOArray[i]);
if (EvaluationData(theEnv)->EvaluationError)
{
*error = TRUE;
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
/*======================================*/
/* A deftemplate name must be a symbol. */
/*======================================*/
if (theDOArray[i].type != SYMBOL)
{
*error = TRUE;
ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"symbol");
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
/*===================================================*/
/* Find the deftemplate. For a local save, look only */
/* in the current module. For a visible save, look */
/* in all visible modules. */
/*===================================================*/
if (saveCode == LOCAL_SAVE)
{
theDeftemplate = (struct deftemplate *)
EnvFindDeftemplate(theEnv,ValueToString(theDOArray[i].value));
if (theDeftemplate == NULL)
{
*error = TRUE;
ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"local deftemplate name");
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
}
else if (saveCode == VISIBLE_SAVE)
{
theDeftemplate = (struct deftemplate *)
FindImportedConstruct(theEnv,(char*)"deftemplate",NULL,
ValueToString(theDOArray[i].value),
&tempCount,TRUE,NULL);
if (theDeftemplate == NULL)
{
*error = TRUE;
ExpectedTypeError1(theEnv,(char*)"save-facts",3+i,(char*)"visible deftemplate name");
rm3(theEnv,theDOArray,(long) sizeof(DATA_OBJECT) * *count);
return(NULL);
}
}
/*==================================*/
/* Add a pointer to the deftemplate */
/* to the array being created. */
/*==================================*/
theDOArray[i].type = DEFTEMPLATE_PTR;
theDOArray[i].value = (void *) theDeftemplate;
}
/*===================================*/
/* Return the array of deftemplates. */
/*===================================*/
return(theDOArray);
}
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
}
globle void *FindDeftemplate(
const char *deftemplateName)
{
return EnvFindDeftemplate(GetCurrentEnvironment(),deftemplateName);
}
