847 lines
16 KiB
C++
847 lines
16 KiB
C++
//
|
||
// MODULE: APGTSDTG.CPP
|
||
//
|
||
// PURPOSE: Wrapper for inference api
|
||
//
|
||
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
|
||
//
|
||
// COMPANY: Saltmine Creative, Inc. (206)-633-4743 support@saltmine.com
|
||
//
|
||
// AUTHOR: Roman Mach
|
||
//
|
||
// ORIGINAL DATE: 8-2-96
|
||
//
|
||
// NOTES:
|
||
// 1. Based on Print Troubleshooter DLL
|
||
//
|
||
// Version Date By Comments
|
||
//--------------------------------------------------------------------
|
||
// V0.1 - RM Original
|
||
// V0.2 6/4/97 RWM Local Version for Memphis
|
||
// V0.3 04/09/98 JM/OK+ Local Version for NT5
|
||
//
|
||
|
||
//#include "windows.h"
|
||
#include "stdafx.h"
|
||
|
||
#include "time.h"
|
||
|
||
#include "apgts.h"
|
||
#include "ErrorEnums.h"
|
||
#include "bnts.h"
|
||
#include "BackupInfo.h"
|
||
#include "cachegen.h"
|
||
#include "apgtsinf.h"
|
||
#include "apgtscmd.h"
|
||
#include "apgtshtx.h"
|
||
#include "apgtscls.h"
|
||
|
||
#include <string.h>
|
||
#include <memory.h>
|
||
|
||
#include "CabUnCompress.h"
|
||
#include "crc.h"
|
||
#include "sniff.h"
|
||
#include "chmread.h"
|
||
|
||
BCache::BCache(TCHAR *binfile, TCHAR *tagstr, TCHAR *szResourcePath, const CString& strFile)
|
||
: GTSAPI(binfile, tagstr, szResourcePath),
|
||
CSniffedNodeContainer(),
|
||
m_NodeState(30),
|
||
m_strFile(strFile)
|
||
{
|
||
SetBNTS(this);
|
||
|
||
m_bNeedModel = TRUE; // TRUE -> Need to read the model before querying the bnts library.
|
||
m_bModelRead = FALSE;
|
||
m_bDeleteModelFile = FALSE;
|
||
m_strModelFile = _T("");
|
||
|
||
m_CurNode = 0;
|
||
|
||
m_pHttpQuery = NULL;
|
||
|
||
m_strResult = _T("");
|
||
|
||
m_NodeState.InitHashTable(47);
|
||
|
||
m_bReverse = false;
|
||
|
||
m_bRunWithKnownProblem = false;
|
||
|
||
return;
|
||
}
|
||
|
||
BCache::~BCache()
|
||
{
|
||
m_NodeState.RemoveAll();
|
||
if (m_bDeleteModelFile)
|
||
{
|
||
DeleteFile((LPCTSTR) m_strModelFile);
|
||
m_bDeleteModelFile = FALSE;
|
||
}
|
||
return;
|
||
}
|
||
|
||
//
|
||
//
|
||
GTSAPI::GTSAPI(TCHAR *binfile, TCHAR *tagstr, TCHAR *szResourcePath) :
|
||
m_CacheGen(TRUE, NULL, NULL)
|
||
{
|
||
// InitializeCriticalSection( &m_csAPI );
|
||
|
||
m_cnid = 0;
|
||
m_dwErr = 0;
|
||
m_pchHtml = NULL;
|
||
m_currid = 0;
|
||
m_pCache = NULL;
|
||
|
||
_tcscpy(m_binfile,binfile);// full path
|
||
_tcscpy(m_tagstr,tagstr);
|
||
_tcscpy(m_szResourcePath,szResourcePath);
|
||
}
|
||
|
||
//
|
||
//
|
||
GTSAPI::~GTSAPI()
|
||
{
|
||
Destroy();
|
||
}
|
||
|
||
void WideToMB(const WCHAR *szIn, CHAR *szOut)
|
||
{
|
||
VERIFY(WideCharToMultiByte(CP_ACP,
|
||
NULL,
|
||
szIn,
|
||
-1,
|
||
szOut,
|
||
MAXBUF,
|
||
NULL, NULL));
|
||
return;
|
||
}
|
||
#ifdef _UNICODE
|
||
// Temporary BNTS wrappers for unicode build with non unicode bnts.dll
|
||
BOOL GTSAPI::BMultiByteReadModel(LPCTSTR szcFn, LPCSTR szFnError)
|
||
{
|
||
CHAR szFn[MAXBUF];
|
||
WideToMB(szcFn, szFn);
|
||
return BNTS::BReadModel(szFn, szFnError);
|
||
}
|
||
|
||
BOOL GTSAPI::BMultiByteNodePropItemStr(LPCTSTR szcPropType, int index)
|
||
{
|
||
CHAR szPropType[MAXBUF];
|
||
WideToMB(szcPropType, szPropType);
|
||
return BNTS::BNodePropItemStr(szPropType, index);
|
||
}
|
||
|
||
BOOL GTSAPI::BMultiByteNetPropItemStr(LPCTSTR szcPropType, int index)
|
||
{
|
||
CHAR szPropType[MAXBUF];
|
||
WideToMB(szcPropType, szPropType);
|
||
return BNTS::BNetPropItemStr(szPropType, index);
|
||
}
|
||
|
||
const WCHAR * GTSAPI::SzcMultiByteResult()
|
||
{
|
||
int len = strlen(BNTS::SzcResult());
|
||
int size = MultiByteToWideChar(CP_ACP,
|
||
NULL,
|
||
BNTS::SzcResult(),
|
||
len,
|
||
NULL,
|
||
0);
|
||
MultiByteToWideChar(CP_ACP,
|
||
NULL,
|
||
BNTS::SzcResult(),
|
||
len + 1,
|
||
m_strResult.GetBufferSetLength(size),
|
||
size);
|
||
m_strResult.ReleaseBuffer();
|
||
return (LPCTSTR) m_strResult;
|
||
}
|
||
|
||
int GTSAPI::IMultiByteNode(LPCTSTR szSymName)
|
||
{
|
||
CHAR szMBSymName[MAXBUF];
|
||
WideToMB(szSymName, szMBSymName);
|
||
return BNTS::INode(szMBSymName);
|
||
}
|
||
|
||
#endif // _UNICODE
|
||
|
||
void BCache::ReadTheDscModel(int From)
|
||
{
|
||
if (m_bNeedModel)
|
||
{
|
||
if (!BReadModel((LPCTSTR) m_strModelFile
|
||
#ifdef _DEBUG
|
||
, "BNTSError.log"
|
||
#endif
|
||
))
|
||
ReportError((DLSTATTYPES) From);
|
||
// Add the nodes that are already instantiated.
|
||
if (m_pHttpQuery)
|
||
m_pHttpQuery->AddNodes(this);
|
||
m_bNeedModel = FALSE;
|
||
|
||
if (m_bDeleteModelFile)
|
||
{
|
||
DeleteFile((LPCTSTR) m_strModelFile);
|
||
m_bDeleteModelFile = FALSE;
|
||
}
|
||
}
|
||
}
|
||
|
||
VOID BCache::AddToCache(CString &strCacheFile, const CString& strCacheFileWithinCHM)
|
||
{
|
||
if (m_CacheGen.ReadCacheFileHeader(strCacheFile, strCacheFileWithinCHM))
|
||
{
|
||
BOOL bErr;
|
||
ASSERT(m_pCache);
|
||
while (m_CacheGen.GetNextCacheEntryFromFile(bErr, m_pCache))
|
||
;
|
||
if (bErr)
|
||
{
|
||
delete m_pCache;
|
||
m_pCache = new CBNCache();
|
||
TRACE(_T("Errors occured while reading the cache file.\n"));
|
||
ReadTheDscModel(TSERR_ENGINE_BNTS_READ_NCAB);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
DWORD BCache::ReadModel()
|
||
{
|
||
BOOL bDelete = FALSE;
|
||
|
||
// this should be fixed eventually to not require a string compare
|
||
// but maybe a flag check that gets passed in
|
||
CString sFilename = m_binfile;
|
||
CString strCacheFile;
|
||
CString strCacheFileWithinCHM;
|
||
|
||
if (m_strFile.GetLength())
|
||
{
|
||
// form Cache file path here assuming it is NOT in chm file
|
||
strCacheFile = m_binfile;
|
||
strCacheFileWithinCHM = m_strFile.Left(m_strFile.GetLength() - 4);
|
||
strCacheFileWithinCHM += SZ_CACHE_NAME;
|
||
}
|
||
else
|
||
{
|
||
strCacheFile = sFilename.Left(sFilename.GetLength() - 4);
|
||
strCacheFile += SZ_CACHE_NAME;
|
||
}
|
||
|
||
if (m_strFile.GetLength() || !sFilename.Right(4).CompareNoCase(DSC_COMPRESSED))
|
||
{
|
||
CCabUnCompress cab;
|
||
CString strDirBuf;
|
||
if (!GetTempPath( MAX_PATH , strDirBuf.GetBufferSetLength(MAX_PATH + 1)))
|
||
{
|
||
strDirBuf.ReleaseBuffer();
|
||
strDirBuf = m_szResourcePath;
|
||
}
|
||
else
|
||
{
|
||
strDirBuf.ReleaseBuffer();
|
||
}
|
||
if (!cab.ExtractCab(sFilename, strDirBuf, m_strFile))
|
||
{
|
||
if (NOT_A_CAB == cab.m_nError)
|
||
{ // The file may be uncompressed already.
|
||
bDelete = FALSE;
|
||
}
|
||
else
|
||
{
|
||
ReportError(TSERR_ENGINE_EXTRACT);
|
||
}
|
||
}
|
||
else
|
||
{ // Normal cab file expanded successfully.
|
||
sFilename = strDirBuf;
|
||
sFilename += cab.GetLastFile();
|
||
DWORD dwAttribs = GetFileAttributes((LPCTSTR) sFilename);
|
||
dwAttribs = dwAttribs & ~FILE_ATTRIBUTE_READONLY;
|
||
SetFileAttributes((LPCTSTR) sFilename, dwAttribs);
|
||
bDelete = TRUE;
|
||
}
|
||
}
|
||
/*
|
||
if (!BReadModel(sFilename
|
||
#ifdef _DEBUG
|
||
, "BNTSError.log"
|
||
#endif
|
||
))
|
||
ReportError(TSERR_ENGINE);
|
||
*/
|
||
m_strModelFile = sFilename;
|
||
m_bDeleteModelFile = bDelete;
|
||
// Compare the crc value in the cache file with the crc of the dsc file.
|
||
// If they match, fill the cache.
|
||
CCRC crc;
|
||
try
|
||
{
|
||
if (crc.Decode(sFilename, strCacheFile, strCacheFileWithinCHM))
|
||
AddToCache(strCacheFile, strCacheFileWithinCHM);
|
||
else
|
||
ReadTheDscModel(TSERR_ENGINE_BNTS_READ_CACH);
|
||
}
|
||
catch(CGenException *p)
|
||
{
|
||
delete p;
|
||
ReadTheDscModel(TSERR_ENGINE_BNTS_READ_GEN);
|
||
}
|
||
|
||
// if (bDelete)
|
||
// DeleteFile(sFilename);
|
||
|
||
|
||
m_probask = idhFirst + CNode();
|
||
m_bModelRead = TRUE;
|
||
return m_dwErr;
|
||
}
|
||
|
||
// Number of nodes whose states were set at program startup by TSLaunchServ.
|
||
UINT BCache::StatesFromServ()
|
||
{
|
||
return m_pHttpQuery ? m_pHttpQuery->StatesFromServ() : 0;
|
||
}
|
||
|
||
// Number of nodes whose states are now set
|
||
UINT BCache::StatesNowSet()
|
||
{
|
||
return (UINT)m_NodeState.GetCount();
|
||
}
|
||
|
||
//
|
||
//
|
||
DWORD BCache::Initialize(/*CWordList *pWXList*/)
|
||
{
|
||
|
||
if (NULL != m_pCache)
|
||
delete m_pCache;
|
||
m_pCache = new CBNCache();
|
||
if (!m_pCache)
|
||
m_dwErr = EV_GTS_ERROR_IDX_ALLOC_CACHE;
|
||
|
||
ResetNodes();
|
||
|
||
if (!BValidNet())
|
||
ReadModel();
|
||
return m_dwErr;
|
||
}
|
||
|
||
|
||
// override the default function
|
||
//
|
||
// look for possible returns in the header file
|
||
//
|
||
int BCache::GTSGetRecommendations(CNID& cnid, NID rgnid[], bool bSniffed)
|
||
{
|
||
BN_CACHE_ITEM SetupItem;
|
||
SetupItem.uNodeCount = m_cnid;
|
||
SetupItem.uName = m_rgnid;
|
||
SetupItem.uValue = m_rgist;
|
||
int state = SNIFF_INVALID_STATE;
|
||
int label = SNIFF_INVALID_NODE_LABEL;
|
||
|
||
//AfxDebugBreak();
|
||
|
||
// set initial non-sniffed value in array of sniffed states
|
||
if (!bSniffed && !IsReverse())
|
||
m_rgsniff[m_cnid-1] = 0;
|
||
|
||
// flush array of sniffed nodes recently traversed
|
||
if (!bSniffed)
|
||
m_arrNidLastSniffed.RemoveAll();
|
||
|
||
if (m_pCache->FindCacheItem(&SetupItem, cnid, rgnid))
|
||
{
|
||
if (GetState(*rgnid, &state)) // sniffer has this information and can answer what state this node has
|
||
{
|
||
if (NodeSet(*rgnid, state, false)) // set sniffed node current and set its state
|
||
{
|
||
SetAdditionalDataOnNodeSet(*rgnid);
|
||
return GTSGetRecommendations(cnid, rgnid, true); // recursive call - hope BNTS will not recommend a node which is set
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return RECOMMEND_SUCCESS;
|
||
}
|
||
}
|
||
|
||
if (m_bNeedModel)
|
||
{
|
||
ReadTheDscModel(TSERR_ENGINE_BNTS_REC);
|
||
}
|
||
|
||
if (BGetRecommendations())
|
||
{
|
||
cnid = CInt();
|
||
if (cnid > 0)
|
||
{
|
||
const int *pInt = RgInt();
|
||
memcpy(rgnid, pInt, cnid * sizeof(pInt[0]));
|
||
|
||
SetupItem.uNodeCount = m_cnid;
|
||
SetupItem.uName = m_rgnid;
|
||
SetupItem.uValue = m_rgist;
|
||
SetupItem.uRecCount = cnid;
|
||
SetupItem.uRec = rgnid;
|
||
|
||
m_pCache->AddCacheItem(&SetupItem);
|
||
|
||
if (GetState(*rgnid, &state)) // sniffer has this information and can answer what state this node has
|
||
{
|
||
if (NodeSet(*rgnid, state, false)) // set sniffed node current and set its state
|
||
{
|
||
SetAdditionalDataOnNodeSet(*rgnid);
|
||
return GTSGetRecommendations(cnid, rgnid, true); // recursive call - hope BNTS will not recommend a node which is set
|
||
}
|
||
}
|
||
return RECOMMEND_SUCCESS;
|
||
}
|
||
else
|
||
{
|
||
rgnid[0] = nidService;
|
||
cnid = 1;
|
||
return RECOMMEND_NO_MORE_DATA;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// the last node was sniffed and its state was set
|
||
// after that we received FALSE from BGetRecommendation;
|
||
// we unset this node (in order to be able to use BGetRecommendation later on);
|
||
// we return value indicating that BNTS cannot give us any recommendations
|
||
NodeSet(m_rgnid[m_cnid-1], -1, false);
|
||
return RECOMMEND_NO_MORE_DATA;
|
||
}
|
||
|
||
return RECOMMEND_FAIL;
|
||
}
|
||
|
||
void BCache::SetAdditionalDataOnNodeSet(NID nid)
|
||
{
|
||
m_rgsniff[m_cnid-1] = 1;
|
||
m_arrNidLastSniffed.Add(nid);
|
||
}
|
||
|
||
BOOL InArray(UINT num, UINT aNums[], UINT max)
|
||
{
|
||
UINT x = max;
|
||
BOOL bRes = FALSE;
|
||
for (UINT y = 0; y < x; y++)
|
||
{
|
||
if (aNums[y] == num)
|
||
{
|
||
bRes = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
return bRes;
|
||
}
|
||
|
||
// RemoveRecommendations is called for nodes whos' state is less than 100.
|
||
void BCache::RemoveRecommendation(int Nid)
|
||
{
|
||
VERIFY(BNodeSetCurrent(Nid));
|
||
BNodeSet(-1, false);
|
||
if (m_cnid)
|
||
m_cnid--;
|
||
return;
|
||
}
|
||
|
||
//
|
||
//
|
||
UINT GTSAPI::GetNodeList(NID **pNid, IST **pIst)
|
||
{
|
||
*pNid = m_rgnid;
|
||
*pIst = m_rgist;
|
||
return m_cnid;
|
||
}
|
||
|
||
BOOL GTSAPI::BNodeSetCurrent(int node)
|
||
{
|
||
return BNTS::BNodeSetCurrent(node);
|
||
}
|
||
|
||
//
|
||
//
|
||
BOOL BCache::NodeSet(NID nid, IST ist, bool bPrevious)
|
||
{
|
||
BOOL bRes = FALSE;
|
||
|
||
// shouldn't happen...but to be safe
|
||
if (m_cnid >= MAX_NID)
|
||
return FALSE;
|
||
|
||
m_rgnid[m_cnid] = nid;
|
||
m_rgist[m_cnid] = ist;
|
||
|
||
if (false == bPrevious)
|
||
{
|
||
VERIFY(BNodeSetCurrent(nid));
|
||
bRes = BNodeSet(ist, false);
|
||
if (bRes && // bnts worked successfully
|
||
-1 == GetIndexNodeInCache(nid) // this nid is not present in the cache
|
||
)
|
||
m_cnid++;
|
||
}
|
||
else
|
||
{
|
||
bRes = TRUE;
|
||
}
|
||
return bRes;
|
||
}
|
||
|
||
//
|
||
//
|
||
int BCache::GetIndexNodeInCache(NID nid)
|
||
{
|
||
for (unsigned int i = 0; i < m_cnid; i++)
|
||
if (m_rgnid[i] == nid)
|
||
return i;
|
||
return -1;
|
||
}
|
||
|
||
//
|
||
//
|
||
VOID BCache::ResetNodes()
|
||
{
|
||
for (UINT inid = 0; inid < m_cnid; inid++)
|
||
{
|
||
VERIFY(BNodeSetCurrent(m_rgnid[inid]));
|
||
BNodeSet(-1, false); // Nil value
|
||
}
|
||
m_cnid = 0;
|
||
}
|
||
|
||
//
|
||
//
|
||
DWORD GTSAPI::GetStatus()
|
||
{
|
||
return m_dwErr;
|
||
}
|
||
|
||
//
|
||
//
|
||
VOID GTSAPI::Destroy()
|
||
{
|
||
if (m_pchHtml) {
|
||
delete [] m_pchHtml;
|
||
m_pchHtml = NULL;
|
||
}
|
||
|
||
/*
|
||
if (m_pWNList) {
|
||
|
||
if (!m_dwErr)
|
||
m_dwErr = m_pWNList->GetStatus();
|
||
|
||
delete m_pWNList;
|
||
m_pWNList = NULL;
|
||
}
|
||
*/
|
||
if (m_pCache) {
|
||
if (!m_dwErr)
|
||
m_dwErr = m_pCache->GetStatus();
|
||
delete m_pCache;
|
||
m_pCache = NULL;
|
||
}
|
||
}
|
||
|
||
//
|
||
//
|
||
UINT GTSAPI::GetProblemArray(IDH **idh)
|
||
{
|
||
*idh = m_idstore;
|
||
return m_currid;
|
||
}
|
||
|
||
//
|
||
//
|
||
IDH GTSAPI::GetProblemAsk()
|
||
{
|
||
return m_probask;
|
||
}
|
||
|
||
void GTSAPI::AddValue(int value)
|
||
{
|
||
ASSERT(m_currid < MAXPROBID);
|
||
m_idstore[m_currid++] = value;
|
||
return;
|
||
}
|
||
|
||
BOOL BCache::CheckNode(int Node)
|
||
{
|
||
BOOL bCached = m_CacheGen.IsNodePresent(Node);
|
||
if (!bCached && m_bNeedModel)
|
||
{
|
||
ReadTheDscModel(TSERR_ENGINE_BNTS_CHECK);
|
||
}
|
||
return bCached;
|
||
}
|
||
|
||
//-------------------------------------------------------------
|
||
// BNTS Overrides to replace the dsc file with our cache.
|
||
// Need to override everything but BReadModel and BGetRecommendations.
|
||
|
||
int BCache::CNode()
|
||
{
|
||
int cNodes;
|
||
if (FALSE == m_bNeedModel)
|
||
cNodes = GTSAPI::CNode();
|
||
else
|
||
cNodes = m_CacheGen.GetNodeCount();
|
||
return cNodes;
|
||
}
|
||
|
||
BOOL BCache::BImpossible()
|
||
{
|
||
BOOL bImpossible = FALSE;
|
||
if (FALSE == m_bNeedModel)
|
||
bImpossible = GTSAPI::BImpossible();
|
||
return bImpossible;
|
||
}
|
||
|
||
BOOL BCache::BNetPropItemStr(LPCTSTR szPropType, int index)
|
||
{
|
||
BOOL bGoodIndex = FALSE;
|
||
char sznPropType[MAX_SYM_NAME_BUF_LEN];
|
||
int nPropLen = MAX_SYM_NAME_BUF_LEN;
|
||
if (!GTSCacheGenerator::TcharToChar(sznPropType, szPropType, nPropLen))
|
||
return FALSE;
|
||
if (CheckNode(m_CurNode))
|
||
{
|
||
bGoodIndex = m_CacheGen.FindNetworkProperty(sznPropType, m_strResult, index);
|
||
if (!bGoodIndex && !m_bNeedModel)
|
||
{
|
||
bGoodIndex = GTSAPI::BNetPropItemStr(szPropType, index);
|
||
m_strResult = GTSAPI::SzcResult();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
bGoodIndex = GTSAPI::BNetPropItemStr(szPropType, index);
|
||
m_strResult = GTSAPI::SzcResult();
|
||
}
|
||
return bGoodIndex;
|
||
}
|
||
|
||
BOOL BCache::BNodeSetCurrent(int node)
|
||
{
|
||
BOOL bNodeSet = TRUE;
|
||
if (CheckNode(node) && TRUE == m_bNeedModel)
|
||
{
|
||
m_CurNode = node;
|
||
}
|
||
else
|
||
{
|
||
bNodeSet = GTSAPI::BNodeSetCurrent(node);
|
||
m_CurNode = node;
|
||
}
|
||
return bNodeSet;
|
||
}
|
||
|
||
int BCache::INode(LPCTSTR szNodeSymName)
|
||
{
|
||
UINT index = 0;
|
||
if (FALSE == m_bNeedModel)
|
||
index = GTSAPI::INode(szNodeSymName);
|
||
else
|
||
if (!m_CacheGen.GetNodeIDFromSymName(szNodeSymName, index))
|
||
{ // Have to have BNTS load the network and the the symbolic name.
|
||
ReadTheDscModel(TSERR_ENGINE_CACHE_LOW);
|
||
index = GTSAPI::INode(szNodeSymName);
|
||
}
|
||
return (signed int) index;
|
||
}
|
||
|
||
ESTDLBL BCache::ELblNode()
|
||
{
|
||
UINT NodeLable;
|
||
ESTDLBL Lable;
|
||
if (FALSE == m_bNeedModel)
|
||
{
|
||
Lable = GTSAPI::ELblNode();
|
||
}
|
||
else
|
||
{
|
||
VERIFY(m_CacheGen.GetLabelOfNode(m_CurNode, NodeLable));
|
||
Lable = (ESTDLBL) NodeLable;
|
||
}
|
||
return Lable;
|
||
}
|
||
|
||
int BCache::INodeCst()
|
||
{
|
||
int cStates = 2;
|
||
|
||
return cStates;
|
||
}
|
||
|
||
BOOL GTSAPI::BNodeSet(int state, bool bset)
|
||
{
|
||
return BNTS::BNodeSet(state, bset);
|
||
}
|
||
|
||
BOOL BCache::BNodeSet(int istate, bool bSet)
|
||
{
|
||
BOOL bNodeWasSet = TRUE;
|
||
if (FALSE == m_bNeedModel)
|
||
bNodeWasSet = GTSAPI::BNodeSet(istate, bSet);
|
||
if (bNodeWasSet)
|
||
{
|
||
if (-1 != istate)
|
||
m_NodeState.SetAt(m_CurNode, istate);
|
||
else
|
||
m_NodeState.RemoveKey(m_CurNode);
|
||
}
|
||
return bNodeWasSet;
|
||
}
|
||
|
||
int BCache::INodeState()
|
||
{ // This is ok. See BNodeSet.
|
||
int state;
|
||
if (!m_NodeState.Lookup(m_CurNode, state))
|
||
state = 0;
|
||
return state;
|
||
}
|
||
|
||
void BCache::NodeStateName(int istate)
|
||
{
|
||
if (FALSE == m_bNeedModel)
|
||
{
|
||
GTSAPI::NodeStateName(istate);
|
||
m_strResult = GTSAPI::SzcResult();
|
||
}
|
||
else
|
||
{
|
||
BOOL bFound;
|
||
switch(istate)
|
||
{
|
||
case 0:
|
||
bFound = m_CacheGen.FindNodeProperty(m_CurNode, G_S0_NAME, m_strResult, 0);
|
||
break;
|
||
case 1:
|
||
bFound = m_CacheGen.FindNodeProperty(m_CurNode, G_S1_NAME, m_strResult, 0);
|
||
break;
|
||
default:
|
||
bFound = FALSE;
|
||
}
|
||
if (!bFound)
|
||
{
|
||
ASSERT(FALSE);
|
||
m_strResult = _T("");
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
void BCache::NodeSymName()
|
||
{
|
||
if (FALSE == m_bNeedModel)
|
||
{
|
||
GTSAPI::NodeSymName();
|
||
m_strResult = GTSAPI::SzcResult();
|
||
}
|
||
else if (CheckNode(m_CurNode))
|
||
{
|
||
VERIFY(m_CacheGen.FindNodeProperty(m_CurNode, G_SYMBOLIC_NAME, m_strResult, 0));
|
||
}
|
||
return;
|
||
}
|
||
|
||
void BCache::NodeFullName()
|
||
{
|
||
if (FALSE == m_bNeedModel)
|
||
{
|
||
GTSAPI::NodeFullName();
|
||
m_strResult = GTSAPI::SzcResult();
|
||
}
|
||
else
|
||
{
|
||
VERIFY(m_CacheGen.FindNodeProperty(m_CurNode, G_FULL_NAME, m_strResult, 0));
|
||
}
|
||
return;
|
||
}
|
||
|
||
BOOL BCache::BNodePropItemStr(LPCTSTR szPropType, int index)
|
||
{
|
||
BOOL bGoodIndex = FALSE;
|
||
char sznPropType[MAX_SYM_NAME_BUF_LEN];
|
||
int nPropTypeLen = MAX_SYM_NAME_BUF_LEN;
|
||
if (!GTSCacheGenerator::TcharToChar(sznPropType, szPropType, nPropTypeLen))
|
||
return FALSE;
|
||
if (FALSE == m_bNeedModel)
|
||
{
|
||
bGoodIndex = GTSAPI::BNodePropItemStr(szPropType, index);
|
||
m_strResult = GTSAPI::SzcResult();
|
||
}
|
||
else
|
||
{
|
||
bGoodIndex = m_CacheGen.FindNodeProperty(m_CurNode, sznPropType, m_strResult, index);
|
||
}
|
||
return bGoodIndex;
|
||
}
|
||
|
||
bool BCache::BValidNet()
|
||
{
|
||
bool bValidNet;
|
||
if (FALSE == m_bModelRead) // Set to true in BCache::ReadModel.
|
||
bValidNet = false; // Causes the readmodel function to be called.
|
||
else if (FALSE == m_bNeedModel)
|
||
bValidNet = GTSAPI::BValidNet();
|
||
else
|
||
bValidNet = true;
|
||
return bValidNet;
|
||
}
|
||
|
||
LPCTSTR BCache::SzcResult() const
|
||
{
|
||
return (LPCTSTR) m_strResult;
|
||
}
|
||
|
||
const CArray<int, int>& BCache::GetArrLastSniffed()
|
||
{
|
||
return m_arrNidLastSniffed;
|
||
}
|
||
|
||
int BCache::GetCountRecommendedNodes()
|
||
{
|
||
return m_cnid;
|
||
}
|
||
|
||
int BCache::GetCountSniffedRecommendedNodes()
|
||
{
|
||
for (unsigned int i = 0, j = 0; i < m_cnid; i++)
|
||
if (m_rgsniff[i] == 1)
|
||
j++;
|
||
return j;
|
||
}
|
||
|
||
bool BCache::IsReverse()
|
||
{
|
||
return m_bReverse;
|
||
}
|
||
|
||
void BCache::SetReverse(bool reverse)
|
||
{
|
||
m_bReverse = reverse;
|
||
}
|
||
|
||
void BCache::SetRunWithKnownProblem(bool yes)
|
||
{
|
||
m_bRunWithKnownProblem = yes;
|
||
}
|
||
|
||
bool BCache::IsRunWithKnownProblem()
|
||
{
|
||
return m_bRunWithKnownProblem;
|
||
}
|
||
|