You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
874 lines
17 KiB
874 lines
17 KiB
//
|
|
// MODULE: CACHEGEN.CPP
|
|
//
|
|
// PURPOSE: Cache File Generator and Reader for BN Networks
|
|
//
|
|
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
|
|
//
|
|
// COMPANY: Saltmine Creative, Inc. (206)-284-7511 [email protected]
|
|
//
|
|
// AUTHOR: Roman Mach
|
|
//
|
|
// ORIGINAL DATE: 8/7/97
|
|
//
|
|
// NOTES:
|
|
// 1.
|
|
//
|
|
// Version Date By Comments
|
|
//--------------------------------------------------------------------
|
|
// V0.2 8/7/97 RM Local Version for Memphis
|
|
// V0.3 04/09/98 JM/OK+ Local Version for NT5
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include <afxwin.h>
|
|
#include <afxtempl.h>
|
|
|
|
#include "apgts.h"
|
|
#include "bnts.h"
|
|
#include "cachegen.h"
|
|
|
|
#include "BackupInfo.h"
|
|
#include "apgtsinf.h"
|
|
#include "ChmRead.h"
|
|
|
|
|
|
int nodecomp(const void *elem1, const void *elem2);
|
|
|
|
//
|
|
//
|
|
GTSCacheGenerator::GTSCacheGenerator(BOOL bScanAll, const char *szLogFile, const char *szBNTSLogFile)
|
|
{
|
|
m_fp = NULL;
|
|
m_bScanAll = bScanAll;
|
|
m_szBNTSLogFile = szBNTSLogFile;
|
|
if (szLogFile != NULL)
|
|
m_fp = fopen(szLogFile, "w");
|
|
m_nCount = 0;
|
|
m_nItemCount = 0;
|
|
m_headposition = 0;
|
|
m_filedata = NULL;
|
|
m_netstartoffset = 0;
|
|
m_nodeorder = NULL;
|
|
}
|
|
|
|
//
|
|
//
|
|
GTSCacheGenerator::~GTSCacheGenerator()
|
|
{
|
|
if (m_fp)
|
|
fclose(m_fp);
|
|
if (m_filedata)
|
|
free(m_filedata);
|
|
if (m_nodeorder)
|
|
free(m_nodeorder);
|
|
|
|
}
|
|
|
|
bool GTSCacheGenerator::TcharToChar(char szOut[], LPCTSTR szIn, int &OutLen)
|
|
{
|
|
int x = 0;
|
|
while(NULL != szIn[x] && x < OutLen)
|
|
{
|
|
szOut[x] = (char) szIn[x];
|
|
x++;
|
|
}
|
|
if (x < OutLen)
|
|
szOut[x] = NULL;
|
|
return x < OutLen;
|
|
}
|
|
//
|
|
//
|
|
/*
|
|
void GTSCacheGenerator::LogOut(TCHAR *szcFormat, ...)
|
|
{
|
|
va_list ptr;
|
|
|
|
if (!m_fp)
|
|
return;
|
|
|
|
if (!szcFormat)
|
|
return;
|
|
|
|
va_start(ptr, szcFormat);
|
|
vfprintf(m_fp, szcFormat, ptr);
|
|
va_end(ptr);
|
|
}
|
|
*/
|
|
|
|
#ifdef _DEBUG
|
|
#define LogOut ::AfxTrace
|
|
//#define LogOut 1 ? (void)0 : ::AfxTrace
|
|
#else
|
|
#define LogOut 1 ? (void)0 : ::AfxTrace
|
|
#endif
|
|
|
|
//
|
|
//
|
|
int nodecomp(const void *elem1, const void *elem2)
|
|
{
|
|
return (((GTS_NODE_ORDER *)elem1)->depth - ((GTS_NODE_ORDER *)elem2)->depth);
|
|
}
|
|
|
|
//
|
|
//
|
|
void GTSCacheGenerator::SaveNetItem(CPtrList *nsp, BNTS *bp, FILE *fp, LPCSTR name)
|
|
{
|
|
GTS_NODE_ITEM *ni;
|
|
|
|
if (!bp->BNetPropItemStr( name, 0 ))
|
|
return;
|
|
|
|
ni = new GTS_NODE_ITEM(name);
|
|
|
|
int j = 0;
|
|
while (bp->BNetPropItemStr( name, j++ ))
|
|
{
|
|
CString sTemp = bp->SzcResult();
|
|
ni->sStringArr.Add(sTemp);
|
|
}
|
|
|
|
nsp->AddTail(ni);
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::NodeTraverse( FILE *fp,
|
|
BNTS *bp,
|
|
int depth,
|
|
CArray<int,int> &newnodes,
|
|
CArray<int,int> &newstates,
|
|
int currnode,
|
|
int currstate)
|
|
{
|
|
BOOL bEnd = FALSE;
|
|
int i, j;
|
|
|
|
if (depth > 30)
|
|
{
|
|
LogOut(_T("Depth Exceeded\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
// uninstantiate
|
|
UninstantiateAll(bp);
|
|
|
|
newnodes.Add(currnode);
|
|
newstates.Add(currstate);
|
|
|
|
depth++;
|
|
|
|
for (i=0;i<newnodes.GetSize();i++)
|
|
{
|
|
if (bp->BNodeSetCurrent(newnodes[i]))
|
|
{
|
|
bp->NodeSymName();
|
|
|
|
CString sTemp = bp->SzcResult();
|
|
|
|
LogOut(_T("%s"), sTemp);
|
|
|
|
ESTDLBL albl = bp->ELblNode();
|
|
|
|
if (albl == ESTDLBL_problem)
|
|
{
|
|
LogOut(_T("(prob)"));
|
|
}
|
|
else if (albl == ESTDLBL_info)
|
|
{
|
|
LogOut(_T("(info)"));
|
|
}
|
|
else if (albl == ESTDLBL_fixobs ||
|
|
albl == ESTDLBL_fixunobs ||
|
|
albl == ESTDLBL_unfix)
|
|
{
|
|
LogOut(_T("(fix)"));
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("(?)"));
|
|
}
|
|
}
|
|
|
|
LogOut(_T("(%d=%d) "), newnodes[i], newstates[i]);
|
|
}
|
|
|
|
SetNodes( bp, newnodes, newstates );
|
|
|
|
BOOL bRec = FALSE;
|
|
|
|
if (!bp->BGetRecommendations())
|
|
{
|
|
bRec = TRUE;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
|
|
const int *rg = bp->RgInt();
|
|
|
|
i = 0;
|
|
|
|
if (bRec)
|
|
{
|
|
if (bp->BImpossible())
|
|
{
|
|
LogOut(_T("IMPOSSIBLE\n"));
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("RECOMMENDATION ERROR\n"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bp->BImpossible())
|
|
{
|
|
LogOut(_T("IMPOSSIBLE (Have Rec)\n"));
|
|
}
|
|
else
|
|
{
|
|
int reccount = bp->CInt();
|
|
|
|
if (reccount)
|
|
{
|
|
int nodecount = (int)newstates.GetSize();
|
|
|
|
if (nodecount)
|
|
{
|
|
|
|
BOOL bFound = FALSE;
|
|
|
|
for (i=0;i<reccount;i++)
|
|
{
|
|
bFound = FALSE;
|
|
|
|
for (j=0;j<nodecount;j++)
|
|
{
|
|
if (newnodes[j] == rg[i])
|
|
{
|
|
bFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bFound)
|
|
break;
|
|
}
|
|
|
|
if (!bFound)
|
|
{
|
|
LogOut(_T("RECOMMENDATION: "));
|
|
|
|
if (bp->BNodeSetCurrent(rg[i]))
|
|
{
|
|
CString sTemp1 = "Error";
|
|
CString sTemp2 = "Error";
|
|
|
|
if (bp->BNodePropItemStr( "HNodeHd", 0 ))
|
|
sTemp1 = bp->SzcResult();
|
|
|
|
bp->NodeSymName();
|
|
|
|
sTemp2 = bp->SzcResult();
|
|
|
|
LogOut(_T("%s (%s) (Node: %d)"), sTemp1, sTemp2, rg[i]);
|
|
|
|
if (m_nodeorder)
|
|
{
|
|
if (m_nodeorder[rg[i]].depth > depth)
|
|
m_nodeorder[rg[i]].depth = depth;
|
|
}
|
|
|
|
UINT realcount = 0;
|
|
for (j=0;j<nodecount;j++)
|
|
if (newstates[j] != STATE_UNKNOWN)
|
|
realcount++;
|
|
|
|
fwrite(&realcount, sizeof (UINT), 1, fp);
|
|
|
|
for (j=0;j<nodecount;j++)
|
|
if (newstates[j] != STATE_UNKNOWN)
|
|
{
|
|
GTS_CACHE_NODE cnode;
|
|
cnode.node = newnodes[j];
|
|
cnode.state = newstates[j];
|
|
|
|
fwrite(&cnode, sizeof (cnode), 1, fp);
|
|
}
|
|
|
|
// write to cache out file
|
|
UINT ucount = reccount;
|
|
fwrite(&ucount, sizeof (UINT), 1, fp);
|
|
|
|
for (j=0;j<reccount;j++)
|
|
{
|
|
UINT rgval = rg[j];
|
|
fwrite(&rgval, sizeof (UINT), 1, fp);
|
|
}
|
|
|
|
m_nCount++;
|
|
}
|
|
LogOut(_T("\n"));
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("NO RECOMMENDATIONS - ALL AVAILABLE MARKED AS UNKNOWN\n"));
|
|
bEnd = TRUE;
|
|
}
|
|
}
|
|
else
|
|
LogOut(_T("STATE COUNT 0 - INTERNAL ERROR\n"));
|
|
}
|
|
else
|
|
LogOut(_T("NO RECOMMENDATIONS\n"));
|
|
}
|
|
}
|
|
|
|
LogOut(_T("\n"));
|
|
|
|
|
|
// recommendations - let's figure out what to do with them
|
|
|
|
// the first rec in the returned array will be array[1] in the set array
|
|
// so we have to watch for that
|
|
|
|
if (bp->CInt() && !bEnd)
|
|
{
|
|
// have rec
|
|
CArray<int,int> states;
|
|
|
|
int node = rg[i];
|
|
|
|
if (bp->BNodeSetCurrent(node))
|
|
{
|
|
ESTDLBL albl = bp->ELblNode();
|
|
|
|
if (albl == ESTDLBL_info)
|
|
{
|
|
states.Add(0);
|
|
states.Add(1);
|
|
if (m_bScanAll)
|
|
states.Add(STATE_UNKNOWN);
|
|
}
|
|
else if (albl == ESTDLBL_fixobs ||
|
|
albl == ESTDLBL_fixunobs ||
|
|
albl == ESTDLBL_unfix)
|
|
{
|
|
states.Add(0);
|
|
if (m_bScanAll)
|
|
states.Add(STATE_UNKNOWN);
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("Unexpected Node Type\n"));
|
|
}
|
|
}
|
|
else
|
|
LogOut(_T("Can't set node current\n"));
|
|
|
|
int count = (int)states.GetSize();
|
|
|
|
for (i=0;i<count;i++)
|
|
{
|
|
if (!NodeTraverse( fp, bp, depth, newnodes, newstates, node, states[i] ))
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// done, remove references to our current node
|
|
newnodes.RemoveAt(depth - 1);
|
|
newstates.RemoveAt(depth - 1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
void GTSCacheGenerator::UninstantiateAll(BNTS *bp)
|
|
{
|
|
int count = (int)m_oldnodes.GetSize();
|
|
// uninstantiate all nodes
|
|
if (!count)
|
|
return;
|
|
|
|
for (int j=0;j<count;j++)
|
|
{
|
|
if (bp->BNodeSetCurrent(m_oldnodes[j]))
|
|
{
|
|
if (bp->BNodeSet(-1))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("Can't uninstantiate node\n"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("Can't set node %d to uninstantiate\n"), m_oldnodes[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
void GTSCacheGenerator::SetNodes(BNTS *bp, CArray<int,int> &nodes, CArray<int,int> &states)
|
|
{
|
|
m_oldnodes.Copy(nodes);
|
|
|
|
int count = (int)nodes.GetSize();
|
|
|
|
if (!count)
|
|
return;
|
|
|
|
LogOut(_T("\nSetNodes:"));
|
|
for (int j=0;j<count;j++)
|
|
{
|
|
if (bp->BNodeSetCurrent(nodes[j]))
|
|
{
|
|
if (states[j] != STATE_UNKNOWN)
|
|
{
|
|
LogOut(_T("(%d=%d)"), nodes[j], states[j]);
|
|
|
|
if (bp->BNodeSet(states[j], false))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
LogOut(_T("Can't set node\n"));
|
|
}
|
|
}
|
|
else
|
|
LogOut(_T("(%d=X)"), nodes[j]);
|
|
}
|
|
else
|
|
LogOut(_T("Can't set node %d\n"), nodes[j]);
|
|
}
|
|
|
|
LogOut(_T("\n"));
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::ReadCacheFileHeader(CString &sCacheFilename, const CString& strCacheFileWithinCHM)
|
|
{
|
|
GTS_CACHE_FILE_HEADER header;
|
|
bool bUseCHM = strCacheFileWithinCHM.GetLength() != 0;
|
|
|
|
if (bUseCHM)
|
|
{
|
|
DWORD size =0;
|
|
if (S_OK != ::ReadChmFile(sCacheFilename, strCacheFileWithinCHM, (void**)&m_filedata, &size))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UINT size;
|
|
// must be binary
|
|
FILE *cfp = _tfopen(sCacheFilename, _T("rb"));
|
|
if (cfp==NULL)
|
|
{
|
|
LogOut(_T("Error opening cache file for reading\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
// get file size
|
|
if (fseek(cfp, 0, SEEK_END))
|
|
{
|
|
LogOut(_T("Can't set pos to end of file\n"));
|
|
fclose(cfp);
|
|
return FALSE;
|
|
}
|
|
|
|
fpos_t position;
|
|
if (fgetpos(cfp, &position))
|
|
{
|
|
LogOut(_T("Can't get pos at end of file\n"));
|
|
fclose(cfp);
|
|
return FALSE;
|
|
}
|
|
|
|
size = (UINT) position;
|
|
|
|
rewind(cfp);
|
|
|
|
// allocate space for file
|
|
m_filedata = (char *) malloc(size);
|
|
if (m_filedata == NULL)
|
|
{
|
|
LogOut(_T("Error allocating memory\n"));
|
|
fclose(cfp);
|
|
return FALSE;
|
|
}
|
|
|
|
if (fread(m_filedata, size, 1, cfp) != 1)
|
|
{
|
|
LogOut(_T("Error reading file into memory\n"));
|
|
fclose(cfp);
|
|
return FALSE;
|
|
}
|
|
|
|
fclose(cfp);
|
|
}
|
|
|
|
memcpy(&header, m_filedata, sizeof(header));
|
|
|
|
if (memcmp(header.signature, GTS_CACHE_SIG, sizeof (header.signature)) != 0)
|
|
{
|
|
LogOut(_T("Bad file signature!\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!header.count)
|
|
{
|
|
LogOut(_T("No items in file!\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
m_netstartoffset = header.netoffset;
|
|
|
|
LogOut(_T("ItemCount: %d\n"), header.count);
|
|
|
|
m_nItemCount = header.count;
|
|
|
|
m_cachepos = (GTS_CACHE_FILE_SETDATA *) (m_filedata + sizeof (GTS_CACHE_FILE_HEADER));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::FindNetworkProperty(LPCSTR szName, CString &sResult, int index)
|
|
{
|
|
if (m_filedata == NULL)
|
|
return FALSE;
|
|
|
|
GTS_CACHE_PROP_NETSTART_BLK *netstart =
|
|
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
|
|
|
|
GTS_CACHE_PROP_STR_BLK *netstrblk =
|
|
(GTS_CACHE_PROP_STR_BLK *) (m_filedata + netstart->netpropoffset);
|
|
|
|
for (UINT i = 0; i < netstart->netpropcount; i++, netstrblk++)
|
|
{
|
|
LPCSTR szItem = (LPCSTR) (m_filedata + netstrblk->nameoffset);
|
|
if (!strcmp(szName, szItem))
|
|
{
|
|
if (!index)
|
|
{
|
|
sResult = (LPCSTR) (m_filedata + netstrblk->stringoffset);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
LPCSTR szStrArrItem = (LPCSTR) (m_filedata + netstrblk->stringoffset);
|
|
int len = strlen(szStrArrItem);
|
|
|
|
for (int j=0;(j < index) && len ;j++)
|
|
{
|
|
szStrArrItem += len + 1;
|
|
len = strlen(szStrArrItem);
|
|
}
|
|
|
|
if (!len)
|
|
return FALSE;
|
|
|
|
sResult = szStrArrItem;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::FindNodeProperty(UINT nodeid, LPCSTR szName, CString &sResult, int index)
|
|
{
|
|
if (m_filedata == NULL)
|
|
return FALSE;
|
|
|
|
GTS_CACHE_PROP_NETSTART_BLK *netstart =
|
|
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
|
|
|
|
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
|
|
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
|
|
|
|
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
|
|
{
|
|
if (nodeid == nodeblk->nodeid)
|
|
{
|
|
GTS_CACHE_PROP_NODESTART_BLK *nodestart =
|
|
(GTS_CACHE_PROP_NODESTART_BLK *)(m_filedata + nodeblk->nodeoffset);
|
|
|
|
GTS_CACHE_PROP_STR_BLK *nodestr =
|
|
(GTS_CACHE_PROP_STR_BLK *)(m_filedata + nodeblk->nodeoffset + sizeof (GTS_CACHE_PROP_NODESTART_BLK));
|
|
|
|
// now try to find string
|
|
for (UINT j=0;j<nodestart->nodestringcount;j++, nodestr++)
|
|
{
|
|
LPCSTR szItem = (LPCSTR) (m_filedata + nodestr->nameoffset);
|
|
|
|
if (!strcmp(szName, szItem))
|
|
{
|
|
if (!index)
|
|
{
|
|
sResult = (LPCSTR) (m_filedata + nodestr->stringoffset);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
LPCSTR szStrArrItem = (LPCSTR) (m_filedata + nodestr->stringoffset);
|
|
int len = strlen(szStrArrItem);
|
|
|
|
for (int j=0;(j < index) && len ;j++)
|
|
{
|
|
szStrArrItem += len + 1;
|
|
len = strlen(szStrArrItem);
|
|
}
|
|
|
|
if (!len)
|
|
return FALSE;
|
|
|
|
sResult = szStrArrItem;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::IsNodePresent(UINT nodeid)
|
|
{
|
|
if (m_filedata == NULL)
|
|
return FALSE;
|
|
|
|
GTS_CACHE_PROP_NETSTART_BLK *netstart =
|
|
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
|
|
|
|
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
|
|
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
|
|
|
|
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
|
|
{
|
|
if (nodeid == nodeblk->nodeid)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// returns the node count for the network, not what's in the file
|
|
//
|
|
int GTSCacheGenerator::GetNodeCount()
|
|
{
|
|
if (m_filedata == NULL)
|
|
return 0;
|
|
|
|
GTS_CACHE_PROP_NETSTART_BLK *netstart =
|
|
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
|
|
|
|
return netstart->nodecountnetwork;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::GetNodeIDFromSymName(LPCTSTR szSymName, UINT &nodeid)
|
|
{
|
|
char sznSymName[MAX_SYM_NAME_BUF_LEN];
|
|
int nSymLen = MAX_SYM_NAME_BUF_LEN;
|
|
if (m_filedata == NULL)
|
|
return FALSE;
|
|
|
|
if (!TcharToChar(sznSymName, szSymName, nSymLen))
|
|
return FALSE;
|
|
|
|
GTS_CACHE_PROP_NETSTART_BLK *netstart =
|
|
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
|
|
|
|
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
|
|
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
|
|
|
|
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
|
|
{
|
|
GTS_CACHE_PROP_NODESTART_BLK *nodestart =
|
|
(GTS_CACHE_PROP_NODESTART_BLK *)(m_filedata + nodeblk->nodeoffset);
|
|
|
|
GTS_CACHE_PROP_STR_BLK *nodestr =
|
|
(GTS_CACHE_PROP_STR_BLK *)(m_filedata + nodeblk->nodeoffset + sizeof (GTS_CACHE_PROP_NODESTART_BLK));
|
|
|
|
// now try to find string
|
|
for (UINT j=0;j<nodestart->nodestringcount;j++, nodestr++)
|
|
{
|
|
LPCSTR szItem = (LPCSTR) (m_filedata + nodestr->nameoffset);
|
|
|
|
if (!strcmp(G_SYMBOLIC_NAME, szItem))
|
|
{
|
|
if (!strcmp(sznSymName, (LPCSTR) (m_filedata + nodestr->stringoffset)))
|
|
{
|
|
nodeid = nodeblk->nodeid;
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::GetLabelOfNode(UINT nodeid, UINT &lbl)
|
|
{
|
|
if (m_filedata == NULL)
|
|
return FALSE;
|
|
|
|
GTS_CACHE_PROP_NETSTART_BLK *netstart =
|
|
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
|
|
|
|
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
|
|
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
|
|
|
|
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
|
|
{
|
|
if (nodeid == nodeblk->nodeid)
|
|
{
|
|
GTS_CACHE_PROP_NODESTART_BLK *nodestart =
|
|
(GTS_CACHE_PROP_NODESTART_BLK *)(m_filedata + nodeblk->nodeoffset);
|
|
|
|
lbl = nodestart->labelnode;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::GetNextCacheEntryFromFile(BOOL &bErr, CBNCache *pCache)
|
|
{
|
|
BOOL bStat = FALSE;
|
|
bErr = TRUE;
|
|
|
|
if (m_filedata == NULL)
|
|
return FALSE;
|
|
|
|
if (!m_nItemCount)
|
|
{
|
|
bErr = FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
m_nItemCount--;
|
|
|
|
BN_CACHE_ITEM CacheItem;
|
|
|
|
// initialize
|
|
CacheItem.uNodeCount = 0;
|
|
CacheItem.uRecCount = 0;
|
|
CacheItem.uName = NULL;
|
|
CacheItem.uValue = NULL;
|
|
CacheItem.uRec = NULL;
|
|
|
|
bStat = GetNCEFF(&CacheItem, pCache);
|
|
|
|
// free allocated space as necessary
|
|
if (CacheItem.uName)
|
|
free(CacheItem.uName);
|
|
if (CacheItem.uValue)
|
|
free(CacheItem.uValue);
|
|
if (CacheItem.uRec)
|
|
free(CacheItem.uRec);
|
|
|
|
if (!bStat)
|
|
{
|
|
bErr = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
bErr = FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
//
|
|
BOOL GTSCacheGenerator::GetNCEFF(BN_CACHE_ITEM *pCacheItem, CBNCache *pCache)
|
|
{
|
|
UINT j;
|
|
UINT setcount;
|
|
UINT reccount;
|
|
|
|
GTS_CACHE_FILE_SETDATA *setp = m_cachepos;
|
|
|
|
setcount = setp->count;
|
|
|
|
if (!setcount || setcount > 1000)
|
|
{
|
|
LogOut(_T("Set Count out of bounds: %d\n"), setcount);
|
|
return FALSE;
|
|
}
|
|
|
|
// initialize
|
|
pCacheItem->uNodeCount = setcount;
|
|
pCacheItem->uName = (UINT *)malloc(setcount * sizeof (UINT));
|
|
pCacheItem->uValue = (UINT *)malloc(setcount * sizeof (UINT));
|
|
|
|
LogOut(_T("Count: %d\n"), setcount);
|
|
|
|
GTS_CACHE_NODE *cachenode = &setp->item[0];
|
|
|
|
// second, read in node = state pairs
|
|
for (j=0;j<setcount;j++, cachenode++)
|
|
{
|
|
pCacheItem->uName[j] = cachenode->node;
|
|
pCacheItem->uValue[j] = cachenode->state;
|
|
|
|
LogOut(_T("(%d,%d)"), cachenode->node, cachenode->state);
|
|
|
|
}
|
|
LogOut(_T("\n"));
|
|
|
|
GTS_CACHE_FILE_RECDATA *recp = (GTS_CACHE_FILE_RECDATA *) cachenode;
|
|
|
|
reccount = recp->count;
|
|
|
|
if (!reccount || reccount > 1000)
|
|
{
|
|
LogOut(_T("Rec Count out of bounds: %d\n"), reccount);
|
|
return FALSE;
|
|
}
|
|
|
|
pCacheItem->uRecCount = reccount;
|
|
pCacheItem->uRec = (UINT *)malloc(reccount * sizeof (UINT));
|
|
|
|
UINT *uitem = &recp->item[0];
|
|
|
|
for (j=0;j<reccount;j++, uitem++)
|
|
{
|
|
pCacheItem->uRec[j] = *uitem;
|
|
|
|
LogOut(_T("(%d)"), *uitem);
|
|
}
|
|
LogOut(_T("\n"));
|
|
|
|
if (!pCache->AddCacheItem(pCacheItem))
|
|
{
|
|
LogOut(_T("Error Adding Item To Cache\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
m_cachepos = (GTS_CACHE_FILE_SETDATA *) uitem;
|
|
|
|
// success!
|
|
return TRUE;
|
|
}
|
|
|