2128 lines
60 KiB
C++
Executable File
2128 lines
60 KiB
C++
Executable File
/*===========================================================================
|
|
FILE:
|
|
CoreDatabase.h
|
|
|
|
DESCRIPTION:
|
|
Declaration of cCoreDatabase class
|
|
|
|
PUBLIC CLASSES AND METHODS:
|
|
cCoreDatabase
|
|
This class represents the run-time (read only) version of the
|
|
core library database
|
|
|
|
Copyright (c) 2011, Code Aurora Forum. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
* Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
* Neither the name of Code Aurora Forum nor
|
|
the names of its contributors may be used to endorse or promote
|
|
products derived from this software without specific prior written
|
|
permission.
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
===========================================================================*/
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Pragmas
|
|
//---------------------------------------------------------------------------
|
|
#pragma once
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Include Files
|
|
//---------------------------------------------------------------------------
|
|
#include <list>
|
|
#include <map>
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
#include "DB2TextFile.h"
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Forward Declarations
|
|
//---------------------------------------------------------------------------
|
|
class cDB2NavTree;
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Prototypes
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Convert a string (in quotes) to a string (minus) quotes and copy into
|
|
// an allocated buffer
|
|
LPCSTR CopyQuotedString( LPSTR pString );
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Definitions
|
|
//---------------------------------------------------------------------------
|
|
|
|
// An empty (but not NULL) string
|
|
extern LPCSTR EMPTY_STRING;
|
|
|
|
// Value seperator for database text
|
|
extern LPCSTR DB2_VALUE_SEP;
|
|
|
|
// Sub-value (i.e. within a particular value) seperator for database text
|
|
extern LPCSTR DB2_SUBVAL_SEP;
|
|
|
|
// Database table file names
|
|
extern LPCSTR DB2_FILE_PROTOCOL_FIELD;
|
|
extern LPCSTR DB2_FILE_PROTOCOL_STRUCT;
|
|
extern LPCSTR DB2_FILE_PROTOCOL_ENTITY;
|
|
extern LPCSTR DB2_FILE_ENUM_MAIN;
|
|
extern LPCSTR DB2_FILE_ENUM_ENTRY;
|
|
|
|
// Database start pointers
|
|
extern const int _binary_QMI_Field_txt_start;
|
|
extern const int _binary_QMI_Struct_txt_start;
|
|
extern const int _binary_QMI_Entity_txt_start;
|
|
extern const int _binary_QMI_Enum_txt_start;
|
|
extern const int _binary_QMI_EnumEntry_txt_start;
|
|
|
|
// Database end pointers
|
|
extern const int _binary_QMI_Field_txt_end;
|
|
extern const int _binary_QMI_Struct_txt_end;
|
|
extern const int _binary_QMI_Entity_txt_end;
|
|
extern const int _binary_QMI_Enum_txt_end;
|
|
extern const int _binary_QMI_EnumEntry_txt_end;
|
|
|
|
|
|
// Status levels for DB2 logging
|
|
enum eDB2StatusLevel
|
|
{
|
|
eDB2_STATUS_BEGIN = -1,
|
|
|
|
eDB2_STATUS_INFO, // Informational string
|
|
eDB2_STATUS_WARNING, // Warning string
|
|
eDB2_STATUS_ERROR, // Error string
|
|
|
|
eDB2_STATUS_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2StatusLevel validity check
|
|
|
|
PARAMETERS:
|
|
lvl [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2StatusLevel lvl )
|
|
{
|
|
bool retVal = false;
|
|
if (lvl > eDB2_STATUS_BEGIN && lvl < eDB2_STATUS_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Class cDB2StatusLog
|
|
//
|
|
// Class that defines status logging interface for DB2 initialization
|
|
// and exit related information
|
|
/*=========================================================================*/
|
|
class cDB2StatusLog
|
|
{
|
|
public:
|
|
// Log an error string
|
|
virtual void Log(
|
|
LPCSTR pLog,
|
|
eDB2StatusLevel lvl = eDB2_STATUS_ERROR ) = 0;
|
|
|
|
// Log an error string
|
|
virtual void Log(
|
|
const std::string & log,
|
|
eDB2StatusLevel lvl = eDB2_STATUS_ERROR ) = 0;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Class cDB2TraceLog
|
|
// Default error logging interface for DB2 initialization and exit
|
|
// related information - sends output to TRACE
|
|
/*=========================================================================*/
|
|
class cDB2TraceLog : public cDB2StatusLog
|
|
{
|
|
public:
|
|
// (Inline) Constructor
|
|
cDB2TraceLog() { };
|
|
|
|
// (Inline) Destructor
|
|
~cDB2TraceLog() { };
|
|
|
|
|
|
// (Inline) Log an error string
|
|
virtual void Log(
|
|
LPCSTR pLog,
|
|
eDB2StatusLevel lvl = eDB2_STATUS_ERROR )
|
|
{
|
|
if (pLog != 0 && pLog[0] != 0)
|
|
{
|
|
std::string formatString = "[0x%02X] ";
|
|
formatString += pLog;
|
|
formatString += '\n';
|
|
|
|
//Note: TRACE is just an alias for printf if DEBUG is used
|
|
TRACE( formatString.c_str(), lvl );
|
|
}
|
|
};
|
|
|
|
// (Inline) Log an error string
|
|
virtual void Log(
|
|
const std::string & log,
|
|
eDB2StatusLevel lvl = eDB2_STATUS_ERROR )
|
|
{
|
|
if (log.size() > 0)
|
|
{
|
|
Log( log.c_str(), lvl );
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
// The default logger (for backwards compatibility)
|
|
extern cDB2TraceLog gDB2DefaultLog;
|
|
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
LoadDB2Table (Free Public Method)
|
|
|
|
DESCRIPTION:
|
|
Load a database table
|
|
|
|
PARAMETERS:
|
|
pFile [ I ] - The file to load the table from
|
|
cont [I/0] - The current/resulting database table
|
|
bDuplicatesOK [ I ] - Duplicate keys acceptable?
|
|
pName [ I ] - Name (for error reporting)
|
|
log [I/O] - Where to log errors
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
template <class Container>
|
|
bool LoadDB2Table(
|
|
LPCSTR pFile,
|
|
Container & cont,
|
|
bool bDuplicatesOK = false,
|
|
LPCSTR pName = 0,
|
|
cDB2StatusLog & log = gDB2DefaultLog )
|
|
{
|
|
// Assume success
|
|
bool bRC = true;
|
|
// Sanity check error reporting name
|
|
if (pName == 0 || pName[0] == 0)
|
|
{
|
|
pName = "?";
|
|
}
|
|
|
|
// Sanity check file name
|
|
if (pFile == 0 || pFile[0] == 0)
|
|
{
|
|
// Bad file
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Invalid file name";
|
|
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_ERROR );
|
|
|
|
return false;
|
|
}
|
|
|
|
ULONG lineNum = 0;
|
|
|
|
// Attempt to open the file
|
|
cDB2TextFile inFile( pFile );
|
|
if (inFile.IsValid() == true)
|
|
{
|
|
std::string line;
|
|
while (inFile.ReadLine( line ) == true)
|
|
{
|
|
std::string lineCopy = line;
|
|
|
|
int nLineSize = lineCopy.size();
|
|
LPSTR pLine = new CHAR[ nLineSize + 1 ];
|
|
if (pLine == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
memcpy( pLine, line.c_str(), nLineSize );
|
|
|
|
// Enforce null terminator
|
|
pLine[ nLineSize ] = 0;
|
|
|
|
typename Container::mapped_type theType;
|
|
bool bOK = theType.FromString( pLine );
|
|
if (bOK == true)
|
|
{
|
|
// Grab key
|
|
typename Container::key_type theKey = theType.GetKey();
|
|
|
|
// Key already exists?
|
|
typename Container::iterator pIter;
|
|
pIter = cont.find( theKey );
|
|
|
|
if (pIter != cont.end() && bDuplicatesOK == false)
|
|
{
|
|
// The key already exists which indicates a (recoverable) error
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Duplicate key, line "
|
|
<< lineNum << " (" << line.c_str() << ")";
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_WARNING );
|
|
|
|
// Free the current object
|
|
pIter->second.FreeAllocatedStrings();
|
|
|
|
// ... and then replace it
|
|
pIter->second = theType;
|
|
}
|
|
else
|
|
{
|
|
typename Container::value_type entry( theKey, theType );
|
|
cont.insert( entry );
|
|
}
|
|
}
|
|
else if (lineCopy.size() > 0)
|
|
{
|
|
// Error parsing line
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Parsing error, line "
|
|
<< lineNum << " (" << line.c_str() << ")";
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_ERROR );
|
|
|
|
theType.FreeAllocatedStrings();
|
|
bRC = false;
|
|
}
|
|
delete [] pLine;
|
|
lineNum++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEBUG
|
|
// Could not open the file
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Error opening file";
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_WARNING );
|
|
#endif
|
|
|
|
bRC = false;
|
|
}
|
|
|
|
return bRC;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
LoadDB2Table (Free Public Method)
|
|
|
|
DESCRIPTION:
|
|
Load a database table
|
|
|
|
PARAMETERS:
|
|
pStart [ I ] - Start location of database
|
|
nSize [ I ] - Size of database
|
|
cont [I/0] - The current/resulting database table
|
|
bDuplicatesOK [ I ] - Duplicate keys acceptable?
|
|
pName [ I ] - Name (for error reporting)
|
|
log [I/O] - Where to log errors
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
template <class Container>
|
|
bool LoadDB2Table(
|
|
const char * pStart,
|
|
const int nSize,
|
|
Container & cont,
|
|
bool bDuplicatesOK = false,
|
|
LPCSTR pName = 0,
|
|
cDB2StatusLog & log = gDB2DefaultLog )
|
|
{
|
|
// Assume success
|
|
bool bRC = true;
|
|
|
|
// Sanity check error reporting name
|
|
if (pName == 0 || pName[0] == 0)
|
|
{
|
|
pName = "?";
|
|
}
|
|
|
|
ULONG lineNum = 0;
|
|
|
|
// Attempt to open the file
|
|
cDB2TextFile inFile( pStart, nSize );
|
|
if (inFile.IsValid() == true)
|
|
{
|
|
std::string line;
|
|
while (inFile.ReadLine( line ) == true)
|
|
{
|
|
std::string lineCopy = line;
|
|
|
|
int nLineSize = lineCopy.size();
|
|
LPSTR pLine = new CHAR[ nLineSize + 1 ];
|
|
if (pLine == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
memcpy( pLine, lineCopy.c_str(), nLineSize );
|
|
|
|
// Enforce null terminator
|
|
pLine[ nLineSize ] = 0;
|
|
|
|
typename Container::mapped_type theType;
|
|
bool bOK = theType.FromString( pLine );
|
|
if (bOK == true)
|
|
{
|
|
// Grab key
|
|
typename Container::key_type theKey = theType.GetKey();
|
|
|
|
// Key already exists?
|
|
typename Container::iterator pIter;
|
|
pIter = cont.find( theKey );
|
|
|
|
if (pIter != cont.end() && bDuplicatesOK == false)
|
|
{
|
|
// The key already exists which indicates a (recoverable) error
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Duplicate key, line "
|
|
<< lineNum << " (" << line.c_str() << ")";
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_WARNING );
|
|
|
|
// Free the current object
|
|
pIter->second.FreeAllocatedStrings();
|
|
|
|
// ... and then replace it
|
|
pIter->second = theType;
|
|
}
|
|
else
|
|
{
|
|
typename Container::value_type entry( theKey, theType );
|
|
cont.insert( entry );
|
|
}
|
|
}
|
|
else if (lineCopy.size() > 0)
|
|
{
|
|
// Error parsing line
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Parsing error, line "
|
|
<< lineNum << " (" << line.c_str() << ")";
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_ERROR );
|
|
|
|
theType.FreeAllocatedStrings();
|
|
bRC = false;
|
|
}
|
|
|
|
delete [] pLine;
|
|
lineNum++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEBUG
|
|
// Could not open the file
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Error opening file";
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_WARNING );
|
|
#endif
|
|
|
|
bRC = false;
|
|
}
|
|
|
|
return bRC;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
FreeDB2Table (Free Public Method)
|
|
|
|
DESCRIPTION:
|
|
Free up the string allocations in a database table, emptying the
|
|
table in the process
|
|
|
|
PARAMETERS:
|
|
cont [ I ] - The database table
|
|
|
|
RETURN VALUE:
|
|
None
|
|
===========================================================================*/
|
|
template <class Container>
|
|
void FreeDB2Table( Container & cont )
|
|
{
|
|
typename Container::iterator pIter = cont.begin();
|
|
while (pIter != cont.end())
|
|
{
|
|
typename Container::mapped_type & theType = pIter->second;
|
|
theType.FreeAllocatedStrings();
|
|
|
|
pIter++;
|
|
}
|
|
|
|
cont.clear();
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2EntityType Enumeration
|
|
//
|
|
// Database protocol entity header/payload type enumeration
|
|
/*=========================================================================*/
|
|
enum eDB2EntityType
|
|
{
|
|
eDB2_ET_ENUM_BEGIN = -1,
|
|
|
|
eDB2_ET_DIAG_REQ, // 0 Synchronous request
|
|
eDB2_ET_DIAG_RSP, // 1 Synchronous response
|
|
eDB2_ET_DIAG_SUBSYS_REQ, // 2 Synchronous subsystem dispatch request
|
|
eDB2_ET_DIAG_SUBSYS_RSP, // 3 Synchronous subsystem dispatch response
|
|
eDB2_ET_DIAG_EVENT, // 4 Asynchronous event
|
|
eDB2_ET_DIAG_LOG, // 5 Asynchronous log
|
|
eDB2_ET_DIAG_NV_ITEM, // 6 NVRAM item read/write
|
|
eDB2_ET_RESERVED7, // 7 Reserved
|
|
eDB2_ET_RESERVED8, // 8 Reserved
|
|
eDB2_ET_DIAG_SUBSYS2_REQ, // 9 Sync subsystem V2 dispatch request
|
|
eDB2_ET_DIAG_SUBSYS2_RSP, // 10 Sync subsystem V2 dispatch response
|
|
eDB2_ET_DIAG_SUBSYS2_ASYNC, // 11 Async subsystem V2 dispatch response
|
|
|
|
eDB2_ET_QMI_BEGIN = 29, // 29 Start of QMI section
|
|
|
|
eDB2_ET_QMI_CTL_REQ, // 30 QMI CTL request
|
|
eDB2_ET_QMI_CTL_RSP, // 31 QMI CTL response
|
|
eDB2_ET_QMI_CTL_IND, // 32 QMI CTL indication
|
|
eDB2_ET_QMI_WDS_REQ, // 33 QMI WDS request
|
|
eDB2_ET_QMI_WDS_RSP, // 34 QMI WDS response
|
|
eDB2_ET_QMI_WDS_IND, // 35 QMI WDS indication
|
|
eDB2_ET_QMI_DMS_REQ, // 36 QMI DMS request
|
|
eDB2_ET_QMI_DMS_RSP, // 37 QMI DMS response
|
|
eDB2_ET_QMI_DMS_IND, // 38 QMI DMS indication
|
|
eDB2_ET_QMI_NAS_REQ, // 39 QMI NAS request
|
|
eDB2_ET_QMI_NAS_RSP, // 40 QMI NAS response
|
|
eDB2_ET_QMI_NAS_IND, // 41 QMI NAS indication
|
|
eDB2_ET_QMI_QOS_REQ, // 42 QMI QOS request
|
|
eDB2_ET_QMI_QOS_RSP, // 43 QMI QOS response
|
|
eDB2_ET_QMI_QOS_IND, // 44 QMI QOS indication
|
|
eDB2_ET_QMI_WMS_REQ, // 45 QMI WMS request
|
|
eDB2_ET_QMI_WMS_RSP, // 46 QMI WMS response
|
|
eDB2_ET_QMI_WMS_IND, // 47 QMI WMS indication
|
|
eDB2_ET_QMI_PDS_REQ, // 48 QMI PDS request
|
|
eDB2_ET_QMI_PDS_RSP, // 49 QMI PDS response
|
|
eDB2_ET_QMI_PDS_IND, // 50 QMI PDS indication
|
|
eDB2_ET_QMI_AUTH_REQ, // 51 QMI AUTH request
|
|
eDB2_ET_QMI_AUTH_RSP, // 52 QMI AUTH response
|
|
eDB2_ET_QMI_AUTH_IND, // 53 QMI AUTH indication
|
|
eDB2_ET_QMI_CAT_REQ, // 54 QMI CAT request
|
|
eDB2_ET_QMI_CAT_RSP, // 55 QMI CAT response
|
|
eDB2_ET_QMI_CAT_IND, // 56 QMI CAT indication
|
|
eDB2_ET_QMI_RMS_REQ, // 57 QMI RMS request
|
|
eDB2_ET_QMI_RMS_RSP, // 58 QMI RMS response
|
|
eDB2_ET_QMI_RMS_IND, // 59 QMI RMS indication
|
|
eDB2_ET_QMI_OMA_REQ, // 60 QMI OMA request
|
|
eDB2_ET_QMI_OMA_RSP, // 61 QMI OMA response
|
|
eDB2_ET_QMI_OMA_IND, // 62 QMI OMA indication
|
|
eDB2_ET_QMI_VOICE_REQ, // 63 QMI voice request
|
|
eDB2_ET_QMI_VOICE_RSP, // 64 QMI voice response
|
|
eDB2_ET_QMI_VOICE_IND, // 65 QMI voice indication
|
|
|
|
eDB2_ET_QMI_END, // 63 End of QMI section
|
|
|
|
eDB2_ET_ENUM_END
|
|
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2EntityType validity check
|
|
|
|
PARAMETERS:
|
|
et [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2EntityType et )
|
|
{
|
|
bool retVal = false;
|
|
if ( (et > eDB2_ET_ENUM_BEGIN && et <= eDB2_ET_DIAG_SUBSYS2_ASYNC)
|
|
|| (et > eDB2_ET_QMI_BEGIN && et < eDB2_ET_QMI_END) )
|
|
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsDiagEntityType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the DIAG protocol?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsDiagEntityType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
if (entityType == eDB2_ET_DIAG_REQ
|
|
|| entityType == eDB2_ET_DIAG_RSP
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS_REQ
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS_RSP
|
|
|| entityType == eDB2_ET_DIAG_EVENT
|
|
|| entityType == eDB2_ET_DIAG_LOG
|
|
|| entityType == eDB2_ET_DIAG_NV_ITEM
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS2_REQ
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS2_RSP
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS2_ASYNC)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsDiagEntityRequestType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the DIAG protocol and if so
|
|
does it represent a request?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsDiagEntityRequestType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
if (entityType == eDB2_ET_DIAG_REQ
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS_REQ
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS2_REQ)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsDiagEntityResponseType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the DIAG protocol and if so
|
|
does it represent a response?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsDiagEntityResponseType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
if (entityType == eDB2_ET_DIAG_RSP
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS_RSP
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS2_RSP)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsDiagEntityAsyncType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the DIAG protocol and if so
|
|
does it represent asynchronous incoming data?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsDiagEntityAsyncType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
if (entityType == eDB2_ET_DIAG_EVENT
|
|
|| entityType == eDB2_ET_DIAG_LOG
|
|
|| entityType == eDB2_ET_DIAG_SUBSYS2_ASYNC)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsQMIEntityType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the QMI protocol?
|
|
|
|
PARAMETERS:
|
|
et [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsQMIEntityType( eDB2EntityType et )
|
|
{
|
|
bool retVal = false;
|
|
if (et > eDB2_ET_QMI_BEGIN && et < eDB2_ET_QMI_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsQMIEntityRequestType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the QMI protocol and if so
|
|
does it represent a request?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsQMIEntityRequestType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
|
|
// One QMI service is always a triplet of REQ/RSP/IND
|
|
DWORD baseVal = (DWORD)eDB2_ET_QMI_BEGIN + 1;
|
|
if ((DWORD)entityType % baseVal == 0)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsQMIEntityResponseType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the QMI protocol and if so
|
|
does it represent a response?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsQMIEntityResponseType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
|
|
// One QMI service is always a triplet of REQ/RSP/IND
|
|
DWORD baseVal = (DWORD)eDB2_ET_QMI_BEGIN + 1;
|
|
if ((DWORD)entityType % baseVal == 1)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsQMIEntityIndicationType (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does the eDB2EntityType value represent the QMI protocol and if so
|
|
does it represent an indication?
|
|
|
|
PARAMETERS:
|
|
entityType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsQMIEntityIndicationType( eDB2EntityType entityType )
|
|
{
|
|
bool retVal = false;
|
|
|
|
// One QMI service is always a triplet of REQ/RSP/IND
|
|
DWORD baseVal = (DWORD)eDB2_ET_QMI_BEGIN + 1;
|
|
if ((DWORD)entityType % baseVal == 2)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2FragmentType Enumeration
|
|
//
|
|
// Database fragment type enumeration - determines in what table
|
|
// (or manner) the fragment is described
|
|
/*=========================================================================*/
|
|
enum eDB2FragmentType
|
|
{
|
|
eDB2_FRAGMENT_TYPE_ENUM_BEGIN = -1,
|
|
|
|
eDB2_FRAGMENT_FIELD, // 0 Simple field fragment
|
|
eDB2_FRAGMENT_STRUCT, // 1 Structure fragment
|
|
eDB2_FRAGMENT_CONSTANT_PAD, // 2 Pad fragment, fixed length (bits)
|
|
eDB2_FRAGMENT_VARIABLE_PAD_BITS, // 3 Pad fragment, variable (bits)
|
|
eDB2_FRAGMENT_VARIABLE_PAD_BYTES, // 4 Pad fragment, variable (bytes)
|
|
eDB2_FRAGMENT_FULL_BYTE_PAD, // 5 Pad fragment, pad to a full byte
|
|
eDB2_FRAGMENT_MSB_2_LSB, // 6 Switch to MSB -> LSB order
|
|
eDB2_FRAGMENT_LSB_2_MSB, // 7 Switch to LSB -> MSB order
|
|
|
|
eDB2_FRAGMENT_TYPE_ENUM_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2FragmentType validity check
|
|
|
|
PARAMETERS:
|
|
fragType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2FragmentType fragType )
|
|
{
|
|
bool retVal = false;
|
|
if (fragType > eDB2_FRAGMENT_TYPE_ENUM_BEGIN
|
|
&& fragType < eDB2_FRAGMENT_TYPE_ENUM_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2ModifierType Enumeration
|
|
//
|
|
// Database fragment modifier type enumeration - determines how a
|
|
// fragment is modified/used
|
|
/*=========================================================================*/
|
|
enum eDB2ModifierType
|
|
{
|
|
eDB2_MOD_TYPE_ENUM_BEGIN = -1,
|
|
|
|
eDB2_MOD_NONE, // 0 Modifier is not used
|
|
eDB2_MOD_CONSTANT_ARRAY, // 1 Constant (elements) array
|
|
eDB2_MOD_VARIABLE_ARRAY, // 2 Variable (elements) array
|
|
eDB2_MOD_OBSOLETE_3, // 3 Constant (bits) array [OBS]
|
|
eDB2_MOD_OBSOLETE_4, // 4 Variable (bits) array [OBS]
|
|
eDB2_MOD_OPTIONAL, // 5 Fragment is optional
|
|
eDB2_MOD_VARIABLE_ARRAY2, // 6 Variable (elements) array, start/stop given
|
|
eDB2_MOD_VARIABLE_ARRAY3, // 7 Variable (elements) array, simple expression
|
|
eDB2_MOD_VARIABLE_STRING1, // 8 Variable length string (bit length)
|
|
eDB2_MOD_VARIABLE_STRING2, // 9 Variable length string (byte length)
|
|
eDB2_MOD_VARIABLE_STRING3, // 10 Variable length string (character length)
|
|
|
|
eDB2_MOD_TYPE_ENUM_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
ModifiedToArray (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
Does this modifier indicate an array?
|
|
|
|
PARAMETERS:
|
|
modType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool ModifiedToArray( eDB2ModifierType modType )
|
|
{
|
|
bool bRC = false;
|
|
if ( (modType == eDB2_MOD_CONSTANT_ARRAY)
|
|
|| (modType == eDB2_MOD_VARIABLE_ARRAY)
|
|
|| (modType == eDB2_MOD_VARIABLE_ARRAY2)
|
|
|| (modType == eDB2_MOD_VARIABLE_ARRAY3) )
|
|
{
|
|
bRC = true;
|
|
}
|
|
|
|
return bRC;
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2ModifierType validity check
|
|
|
|
PARAMETERS:
|
|
modType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2ModifierType modType )
|
|
{
|
|
bool retVal = false;
|
|
if (modType > eDB2_MOD_TYPE_ENUM_BEGIN
|
|
&& modType < eDB2_MOD_TYPE_ENUM_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2FieldType Enumeration
|
|
//
|
|
// Database field type enumeration - determines whether the field in
|
|
// question is a standard type or an enumeration
|
|
/*=========================================================================*/
|
|
enum eDB2FieldType
|
|
{
|
|
eDB2_FIELD_TYPE_ENUM_BEGIN = -1,
|
|
|
|
eDB2_FIELD_STD, // 0 Field is a standard type (see below)
|
|
eDB2_FIELD_ENUM_UNSIGNED, // 1 Field is an unsigned enumerated type
|
|
eDB2_FIELD_ENUM_SIGNED, // 2 Field is a signed enumerated type
|
|
|
|
eDB2_FIELD_TYPE_ENUM_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2FieldType validity check
|
|
|
|
PARAMETERS:
|
|
fieldType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2FieldType fieldType )
|
|
{
|
|
bool retVal = false;
|
|
if (fieldType > eDB2_FIELD_TYPE_ENUM_BEGIN
|
|
&& fieldType < eDB2_FIELD_TYPE_ENUM_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2StdFieldType Enumeration
|
|
//
|
|
// Database standard field type enumeration
|
|
/*=========================================================================*/
|
|
enum eDB2StdFieldType
|
|
{
|
|
eDB2_FIELD_STDTYPE_ENUM_BEGIN = -1,
|
|
|
|
eDB2_FIELD_STDTYPE_BOOL, // 0 Field is a boolean (0/1, false/true)
|
|
eDB2_FIELD_STDTYPE_INT8, // 1 Field is 8-bit signed integer
|
|
eDB2_FIELD_STDTYPE_UINT8, // 2 Field is 8-bit unsigned integer
|
|
eDB2_FIELD_STDTYPE_INT16, // 3 Field is 16-bit signed integer
|
|
eDB2_FIELD_STDTYPE_UINT16, // 4 Field is 16-bit unsigned integer
|
|
eDB2_FIELD_STDTYPE_INT32, // 5 Field is 32-bit signed integer
|
|
eDB2_FIELD_STDTYPE_UINT32, // 6 Field is 32-bit unsigned integer
|
|
eDB2_FIELD_STDTYPE_INT64, // 7 Field is 64-bit signed integer
|
|
eDB2_FIELD_STDTYPE_UINT64, // 8 Field is 64-bit unsigned integer
|
|
eDB2_FIELD_STDTYPE_STRING_A, // 9 ANSI fixed length string
|
|
eDB2_FIELD_STDTYPE_STRING_U, // 10 UNICODE fixed length string
|
|
eDB2_FIELD_STDTYPE_STRING_ANT, // 11 ANSI NULL terminated string
|
|
eDB2_FIELD_STDTYPE_STRING_UNT, // 12 UNICODE NULL terminated string
|
|
eDB2_FIELD_STDTYPE_FLOAT32, // 13 Field is 32-bit floating point value
|
|
eDB2_FIELD_STDTYPE_FLOAT64, // 14 Field is 64-bit floating point value
|
|
eDB2_FIELD_STDTYPE_STRING_U8, // 15 UTF-8 encoded fixed length string
|
|
eDB2_FIELD_STDTYPE_STRING_U8NT, // 16 UTF-8 encoded NULL terminated string
|
|
|
|
eDB2_FIELD_STDTYPE_ENUM_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2StdFieldType validity check
|
|
|
|
PARAMETERS:
|
|
fieldType [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2StdFieldType fieldType )
|
|
{
|
|
bool retVal = false;
|
|
if (fieldType > eDB2_FIELD_STDTYPE_ENUM_BEGIN
|
|
&& fieldType < eDB2_FIELD_STDTYPE_ENUM_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2Operator Enumeration
|
|
//
|
|
// Database conditional fragment operator type enumeration
|
|
/*=========================================================================*/
|
|
enum eDB2Operator
|
|
{
|
|
eDB2_OP_TYPE_ENUM_BEGIN = -1,
|
|
|
|
eDB2_OP_LT,
|
|
eDB2_OP_LTE,
|
|
eDB2_OP_EQ,
|
|
eDB2_OP_NEQ,
|
|
eDB2_OP_GTE,
|
|
eDB2_OP_GT,
|
|
eDB2_OP_DIV,
|
|
eDB2_OP_NDIV,
|
|
|
|
eDB2_OP_TYPE_ENUM_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2Operator validity check
|
|
|
|
PARAMETERS:
|
|
op [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2Operator op )
|
|
{
|
|
bool retVal = false;
|
|
if (op > eDB2_OP_TYPE_ENUM_BEGIN
|
|
&& op < eDB2_OP_TYPE_ENUM_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// eDB2ExpOperator Enumeration
|
|
//
|
|
// Database simple expression operator type enumeration
|
|
/*=========================================================================*/
|
|
enum eDB2ExpOperator
|
|
{
|
|
eDB2_EXPOP_TYPE_ENUM_BEGIN = -1,
|
|
|
|
eDB2_EXPOP_ADD,
|
|
eDB2_EXPOP_SUB,
|
|
eDB2_EXPOP_MUL,
|
|
eDB2_EXPOP_DIV,
|
|
eDB2_EXPOP_REM,
|
|
eDB2_EXPOP_MIN,
|
|
eDB2_EXPOP_MAX,
|
|
|
|
eDB2_EXPOP_TYPE_ENUM_END
|
|
};
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
IsValid (Inline Method)
|
|
|
|
DESCRIPTION:
|
|
eDB2ExpOperator validity check
|
|
|
|
PARAMETERS:
|
|
op [ I ] - Enum value being verified
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
inline bool IsValid( eDB2ExpOperator op )
|
|
{
|
|
bool retVal = false;
|
|
if (op > eDB2_EXPOP_TYPE_ENUM_BEGIN
|
|
&& op < eDB2_EXPOP_TYPE_ENUM_END)
|
|
{
|
|
retVal = true;
|
|
}
|
|
|
|
return retVal;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2ProtocolEntity
|
|
//
|
|
// Structure that defines the schema for the protocol entity table
|
|
/*=========================================================================*/
|
|
struct sDB2ProtocolEntity
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2ProtocolEntity()
|
|
: mType( eDB2_ET_ENUM_BEGIN ),
|
|
mStructID( -1 ),
|
|
mFormatID( -1 ),
|
|
mbInternal( false ),
|
|
mFormatExID( -1 ),
|
|
mpName( EMPTY_STRING )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if (mpName != 0 && mpName != EMPTY_STRING)
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
std::vector <ULONG> GetKey() const
|
|
{
|
|
return mID;
|
|
};
|
|
|
|
// Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
/* Type of protocol entity 'header/payload' */
|
|
eDB2EntityType mType;
|
|
|
|
/* Multi-value ID (includes above type) */
|
|
std::vector <ULONG> mID;
|
|
|
|
/* Associated structure ID (-1 = no structure) */
|
|
int mStructID;
|
|
|
|
/* Associated format specifier (-1 = none) */
|
|
int mFormatID;
|
|
|
|
/* Is this protocol entity internal only? */
|
|
bool mbInternal;
|
|
|
|
/* Associated extended format specifier (-1 = none) */
|
|
int mFormatExID;
|
|
|
|
/* Name of protocol entity */
|
|
LPCSTR mpName;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2Fragment
|
|
//
|
|
// Structure that defines the schema for the protocol structure table
|
|
/*=========================================================================*/
|
|
struct sDB2Fragment
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2Fragment()
|
|
: mStructID( 0 ),
|
|
mFragmentOrder( 0 ),
|
|
mFragmentOffset( 0 ),
|
|
mFragmentType( eDB2_FRAGMENT_TYPE_ENUM_BEGIN ),
|
|
mFragmentValue( 0 ),
|
|
mModifierType( eDB2_MOD_TYPE_ENUM_BEGIN ),
|
|
mpModifierValue( EMPTY_STRING ),
|
|
mpName( EMPTY_STRING )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if (mpName != 0 && mpName != EMPTY_STRING)
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
|
|
if (mpModifierValue != 0 && mpModifierValue != EMPTY_STRING)
|
|
{
|
|
delete [] mpModifierValue;
|
|
mpModifierValue = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
std::pair <ULONG, ULONG> GetKey() const
|
|
{
|
|
std::pair <ULONG, ULONG> key( mStructID, mFragmentOrder );
|
|
return key;
|
|
};
|
|
|
|
// Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
// Build a simple condition string
|
|
static std::string BuildCondition(
|
|
ULONG id,
|
|
eDB2Operator op,
|
|
LONGLONG val,
|
|
bool bF2F );
|
|
|
|
// Evaluate a simple condition
|
|
static bool EvaluateCondition(
|
|
LONGLONG valA,
|
|
eDB2Operator op,
|
|
LONGLONG valB );
|
|
|
|
// Parse a simple condition
|
|
static bool ParseCondition(
|
|
LPCSTR pCondition,
|
|
ULONG & id,
|
|
eDB2Operator & op,
|
|
LONGLONG & val,
|
|
bool & bF2F );
|
|
|
|
// Build a simple expression string
|
|
static std::string BuildExpression(
|
|
ULONG id,
|
|
eDB2ExpOperator op,
|
|
LONGLONG val,
|
|
bool bF2F );
|
|
|
|
// Evaluate a simple expression
|
|
static bool EvaluateExpression(
|
|
LONGLONG valA,
|
|
eDB2ExpOperator op,
|
|
LONGLONG valB,
|
|
LONGLONG & res );
|
|
|
|
// Parse a simple expression
|
|
static bool ParseExpression(
|
|
LPCSTR pExpr,
|
|
ULONG & id,
|
|
eDB2ExpOperator & op,
|
|
LONGLONG & val,
|
|
bool & bF2F );
|
|
|
|
/* Enclosing structure ID */
|
|
ULONG mStructID;
|
|
|
|
/* Order of fragment within structure */
|
|
ULONG mFragmentOrder;
|
|
|
|
/* Offset (in bits) of fragment from beginning of enclosing structure */
|
|
int mFragmentOffset;
|
|
|
|
/* Fragment type, how to interpret the following fragment value */
|
|
eDB2FragmentType mFragmentType;
|
|
|
|
/* Fragment Value */
|
|
ULONG mFragmentValue;
|
|
|
|
/* Modifier type, how to interpret the following modifier value */
|
|
eDB2ModifierType mModifierType;
|
|
|
|
/* Modifier value */
|
|
LPCSTR mpModifierValue;
|
|
|
|
/* Fragment Name */
|
|
LPCSTR mpName;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2Field
|
|
//
|
|
// Structure that defines the schema for the protocol field table
|
|
/*=========================================================================*/
|
|
struct sDB2Field
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2Field()
|
|
: mID( 0 ),
|
|
mSize( 0 ),
|
|
mType( eDB2_FIELD_TYPE_ENUM_BEGIN ),
|
|
mTypeVal( 0 ),
|
|
mbHex( false ),
|
|
mbInternal( false ),
|
|
mDescriptionID( -1 ),
|
|
mpName( EMPTY_STRING )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if ( (mpName != 0)
|
|
&& (mpName != EMPTY_STRING) )
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
ULONG GetKey() const
|
|
{
|
|
return mID;
|
|
};
|
|
|
|
// Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
/* Field ID */
|
|
ULONG mID;
|
|
|
|
/* Size of field (in bits, maximum is 64 bits for integral types) */
|
|
ULONG mSize;
|
|
|
|
/* Field type */
|
|
eDB2FieldType mType;
|
|
|
|
/* Actual field type (eDB2StdFieldType or enum ID) */
|
|
ULONG mTypeVal;
|
|
|
|
/* Display integral fields as hexadecimal? */
|
|
bool mbHex;
|
|
|
|
/* Is this field internal only? */
|
|
bool mbInternal;
|
|
|
|
/* Description of field */
|
|
int mDescriptionID;
|
|
|
|
/* Field name */
|
|
LPCSTR mpName;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2Category
|
|
//
|
|
// Structure that defines the generic category table schema, gives
|
|
// category ID, category name, category description, and parent
|
|
// category relationship (specified as a category ID into the very
|
|
// same table)
|
|
/*=========================================================================*/
|
|
struct sDB2Category
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2Category()
|
|
: mID( 0 ),
|
|
mParentID( -1 ),
|
|
mpName( EMPTY_STRING ),
|
|
mDescriptionID( -1 )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if (mpName != 0 && mpName != EMPTY_STRING)
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
ULONG GetKey() const
|
|
{
|
|
return mID;
|
|
};
|
|
|
|
// Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
/* Category ID */
|
|
ULONG mID;
|
|
|
|
/* Category ID of parent, -1 implies no parent/category is at root */
|
|
int mParentID;
|
|
|
|
/* Category display name */
|
|
LPCSTR mpName;
|
|
|
|
/* Description of category */
|
|
int mDescriptionID;
|
|
};
|
|
|
|
|
|
/*===========================================================================
|
|
METHOD:
|
|
ValidateDB2Categories (Public Method)
|
|
|
|
DESCRIPTION:
|
|
Validate the relationship between a pair of DB category/reference tables
|
|
|
|
NOTE: Discovered problems will be repaired, i.e. bogus/problematic
|
|
category IDs are reset to -1
|
|
|
|
PARAMETERS:
|
|
catMap [ I ] - The category table
|
|
refMap [ I ] - The reference table
|
|
pName [ I ] - Table name (for error reporting)
|
|
log [ I ] - Error log
|
|
|
|
RETURN VALUE:
|
|
bool
|
|
===========================================================================*/
|
|
template <class Key, class NamedType>
|
|
bool ValidateDB2Categories(
|
|
std::map <ULONG, sDB2Category> & catMap,
|
|
std::map <Key, NamedType> & refMap,
|
|
LPCSTR pName,
|
|
cDB2StatusLog & log = gDB2DefaultLog )
|
|
{
|
|
// Assume success
|
|
bool bRC = true;
|
|
std::string err;
|
|
|
|
// Sanity check table name
|
|
if (pName == 0 || pName[0] == 0)
|
|
{
|
|
pName = "?";
|
|
}
|
|
|
|
// First validate/repair category map; stage 1: bad parent IDs
|
|
std::map <ULONG, sDB2Category>::iterator pCats = catMap.begin();
|
|
while (pCats != catMap.end())
|
|
{
|
|
sDB2Category & cat = pCats->second;
|
|
pCats++;
|
|
|
|
if (cat.IsValid() == false)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// The parent ID must be -1 or exist in the category map
|
|
if (cat.mParentID != -1)
|
|
{
|
|
if (catMap.find( cat.mParentID ) == catMap.end())
|
|
{
|
|
// Unable to locate parent category
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Missing ID, parent ID "
|
|
<< cat.mParentID;
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_ERROR );
|
|
|
|
cat.mParentID = -1;
|
|
bRC = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validate/repair category map; stage 2: loop detection
|
|
pCats = catMap.begin();
|
|
while (pCats != catMap.end())
|
|
{
|
|
std::set <int> catsVisited;
|
|
sDB2Category & cat = pCats->second;
|
|
|
|
// Itererate up through parents
|
|
int parentID = cat.mParentID;
|
|
while (parentID != -1)
|
|
{
|
|
// Have we already been here?
|
|
if (catsVisited.find( parentID ) == catsVisited.end())
|
|
{
|
|
// Nope, add ID and go on to the next one
|
|
catsVisited.insert( parentID );
|
|
|
|
std::map <ULONG, sDB2Category>::iterator pParent;
|
|
pParent = catMap.find( parentID );
|
|
|
|
parentID = pParent->second.mParentID;
|
|
}
|
|
else
|
|
{
|
|
// Yes, we are caught in a loop
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Loop in category, parent ID "
|
|
<< cat.mParentID;
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_ERROR );
|
|
|
|
cat.mParentID = -1;
|
|
bRC = false;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
pCats++;
|
|
}
|
|
|
|
// Validate that each reference references valid category IDs
|
|
typename std::map <Key, NamedType>::iterator pTypes = refMap.begin();
|
|
while (pTypes != refMap.end())
|
|
{
|
|
NamedType & theType = pTypes->second;
|
|
std::set <int> cats = theType.mCategoryIDs;
|
|
|
|
std::set <int>::iterator pRefCats = cats.begin();
|
|
while (pRefCats != cats.end())
|
|
{
|
|
if (*pRefCats != -1)
|
|
{
|
|
pCats = catMap.find( *pRefCats );
|
|
if (pCats == catMap.end())
|
|
{
|
|
// Unable to locate category
|
|
std::ostringstream tmp;
|
|
tmp << "DB [" << pName << "] Missing ID, category ID "
|
|
<< *pRefCats << ", reference " << theType.mpName;
|
|
|
|
log.Log( tmp.str(), eDB2_STATUS_ERROR );
|
|
|
|
*pRefCats = -1;
|
|
bRC = false;
|
|
}
|
|
}
|
|
|
|
pRefCats++;
|
|
}
|
|
|
|
pTypes++;
|
|
}
|
|
|
|
return bRC;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2NVItem
|
|
//
|
|
// NVRAM item structure for database schema
|
|
/*=========================================================================*/
|
|
struct sDB2NVItem
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2NVItem()
|
|
: mItem( 0 ),
|
|
mpName( EMPTY_STRING ),
|
|
mDescriptionID( -1 )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if (mpName != 0 && mpName != EMPTY_STRING)
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
ULONG GetKey() const
|
|
{
|
|
return mItem;
|
|
};
|
|
|
|
// Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
/* Category IDs (indices into NV items category table) */
|
|
std::set <int> mCategoryIDs;
|
|
|
|
/* Item number */
|
|
ULONG mItem;
|
|
|
|
/* NV item display name */
|
|
LPCSTR mpName;
|
|
|
|
/* Description of NV item */
|
|
int mDescriptionID;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2Enum
|
|
//
|
|
// Structure that defines the schema for the enum table
|
|
/*=========================================================================*/
|
|
struct sDB2Enum
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2Enum()
|
|
: mID( 0 ),
|
|
mbInternal( false ),
|
|
mpName( EMPTY_STRING ),
|
|
mDescriptionID( -1 )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if (mpName != 0 && mpName != EMPTY_STRING)
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
ULONG GetKey() const
|
|
{
|
|
return mID;
|
|
};
|
|
|
|
// Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
/* Enum ID */
|
|
ULONG mID;
|
|
|
|
/* Is this enum used internally? */
|
|
bool mbInternal;
|
|
|
|
/* Description of enum */
|
|
int mDescriptionID;
|
|
|
|
/* Name of enum */
|
|
LPCSTR mpName;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2EnumEntry
|
|
//
|
|
// Structure that defines the schema for the enum entry table
|
|
/*=========================================================================*/
|
|
struct sDB2EnumEntry
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2EnumEntry()
|
|
: mID( 0 ),
|
|
mValue( -1 ),
|
|
mbHex( false ),
|
|
mpName( EMPTY_STRING ),
|
|
mDescriptionID( -1 )
|
|
{ };
|
|
|
|
// (Inline) Free up our allocated strings
|
|
void FreeAllocatedStrings()
|
|
{
|
|
if (mpName != 0 && mpName != EMPTY_STRING)
|
|
{
|
|
delete [] mpName;
|
|
mpName = 0;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return object key
|
|
std::pair <ULONG, int> GetKey() const
|
|
{
|
|
std::pair <ULONG, int> key( mID, mValue );
|
|
return key;
|
|
};
|
|
|
|
// (Inline) Populate this object from a string
|
|
bool FromString( LPSTR pStr );
|
|
|
|
// Is this object valid?
|
|
bool IsValid() const;
|
|
|
|
/* Enum ID */
|
|
ULONG mID;
|
|
|
|
/* Enum entry value */
|
|
int mValue;
|
|
|
|
/* Hexadecimal flag */
|
|
bool mbHex;
|
|
|
|
/* Enum value name */
|
|
LPCSTR mpName;
|
|
|
|
/* Description of enum value */
|
|
int mDescriptionID;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2SimpleCondition
|
|
//
|
|
// Structure that defines a (parsed) simple condition modifier
|
|
/*=========================================================================*/
|
|
struct sDB2SimpleCondition
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2SimpleCondition()
|
|
: mID( 0 ),
|
|
mOperator( eDB2_OP_TYPE_ENUM_BEGIN ),
|
|
mValue( 0 ),
|
|
mbF2F( false )
|
|
{ };
|
|
|
|
// (Inline) Is this object valid?
|
|
bool IsValid() const
|
|
{
|
|
return ::IsValid( mOperator );
|
|
};
|
|
|
|
/* ID of field whose value is to be used */
|
|
ULONG mID;
|
|
|
|
/* Operator to be used */
|
|
eDB2Operator mOperator;
|
|
|
|
/* Value (or field ID) to compare against */
|
|
LONGLONG mValue;
|
|
|
|
/* Field to field expression? */
|
|
bool mbF2F;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sDB2SimpleExpression
|
|
//
|
|
// Structure that defines a (parsed) simple expression
|
|
/*=========================================================================*/
|
|
struct sDB2SimpleExpression
|
|
{
|
|
public:
|
|
// (Inline) Default constructor
|
|
sDB2SimpleExpression()
|
|
: mID( 0 ),
|
|
mOperator( eDB2_EXPOP_TYPE_ENUM_BEGIN ),
|
|
mValue( 0 ),
|
|
mbF2F( false )
|
|
{ };
|
|
|
|
// (Inline) Is this object valid?
|
|
bool IsValid() const
|
|
{
|
|
return (::IsValid( mOperator ) && mValue != 0);
|
|
};
|
|
|
|
/* ID of field whose value is to be used */
|
|
ULONG mID;
|
|
|
|
/* Operator to be used */
|
|
eDB2ExpOperator mOperator;
|
|
|
|
/* Value (or field ID) to compare against */
|
|
LONGLONG mValue;
|
|
|
|
/* Field to field expression? */
|
|
bool mbF2F;
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Struct sLPCSTRCmp
|
|
//
|
|
// Structure that defines the '<' operator for string comparison
|
|
/*=========================================================================*/
|
|
struct sLPCSTRCmp
|
|
{
|
|
public:
|
|
// (Inline) Is A < B?
|
|
bool operator () (
|
|
LPCSTR pStrA,
|
|
LPCSTR pStrB ) const
|
|
{
|
|
bool bLess = false;
|
|
if (pStrA != 0 && pStrB != 0)
|
|
{
|
|
bLess = (strcmp( pStrA, pStrB ) < 0);
|
|
}
|
|
|
|
return bLess;
|
|
};
|
|
};
|
|
|
|
/*=========================================================================*/
|
|
// Case insensitive compare function
|
|
/*=========================================================================*/
|
|
inline bool InsensitiveCompare( CHAR first, CHAR second )
|
|
{
|
|
return tolower( first ) < tolower( second );
|
|
}
|
|
|
|
/*=========================================================================*/
|
|
// Struct sLPCSTRCmpI
|
|
//
|
|
// Structure that defines the '<' operator for string comparison
|
|
// (case insensitive version)
|
|
/*=========================================================================*/
|
|
struct sLPCSTRCmpI
|
|
{
|
|
public:
|
|
// (Inline) Is A < B?
|
|
bool operator () (
|
|
LPCSTR pStrA,
|
|
LPCSTR pStrB ) const
|
|
{
|
|
bool bLess = false;
|
|
if (pStrA != 0 && pStrB != 0)
|
|
{
|
|
// Is there a simpler stl function for this?
|
|
bLess = std::lexicographical_compare( pStrA,
|
|
pStrA +
|
|
strlen( pStrA ),
|
|
pStrB,
|
|
pStrB +
|
|
strlen( pStrB ),
|
|
InsensitiveCompare );
|
|
}
|
|
|
|
return bLess;
|
|
};
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Typedefs
|
|
//---------------------------------------------------------------------------
|
|
|
|
// The protocol entity table expressed as a type
|
|
typedef std::multimap <std::vector <ULONG>, sDB2ProtocolEntity> tDB2EntityMap;
|
|
|
|
// Protocol entity entity name to ID (reverse) table
|
|
typedef std::map <LPCSTR, std::vector <ULONG>, sLPCSTRCmpI> tDB2EntityNameMap;
|
|
|
|
// The struct table expressed as a type
|
|
typedef std::map <std::pair <ULONG, ULONG>, sDB2Fragment> tDB2FragmentMap;
|
|
|
|
// The field table expressed as a type
|
|
typedef std::map <ULONG, sDB2Field> tDB2FieldMap;
|
|
|
|
// A generic category table expressed as a type
|
|
typedef std::map <ULONG, sDB2Category> tDB2CategoryMap;
|
|
|
|
// NV item table expressed as a map type
|
|
typedef std::map <ULONG, sDB2NVItem> tDB2NVMap;
|
|
|
|
// Enum table expressed as a map type
|
|
typedef std::map <ULONG, sDB2Enum> tDB2EnumNameMap;
|
|
|
|
// Enum entry table expressed as a map type
|
|
typedef std::map <std::pair <ULONG, int>, sDB2EnumEntry> tDB2EnumEntryMap;
|
|
|
|
// The built enumeration map
|
|
typedef std::pair < ULONG, std::map <int, LPCSTR> > tDB2EnumMapPair;
|
|
typedef std::map <LPCSTR, tDB2EnumMapPair, sLPCSTRCmp> tDB2EnumMap;
|
|
|
|
// Parsed fragment modifier map - optional fragment
|
|
typedef std::map <LPCSTR, sDB2SimpleCondition> tDB2OptionalModMap;
|
|
|
|
// Parsed fragment modifier map - simple expression based sizes
|
|
typedef std::map <LPCSTR, sDB2SimpleExpression> tDB2ExpressionModMap;
|
|
|
|
// Parsed fragment modifier map - element count specified arrays
|
|
typedef std::map <LPCSTR, ULONG> tDB2Array1ModMap;
|
|
|
|
// Parsed fragment modifier map - start/stop index specified arrays
|
|
typedef std::map <LPCSTR, std::pair <ULONG, ULONG> > tDB2Array2ModMap;
|
|
|
|
// A protocol entity navigation map expressed as a type
|
|
typedef std::map <std::vector <ULONG>, cDB2NavTree *> tDB2EntityNavMap;
|
|
|
|
|
|
|
|
/*=========================================================================*/
|
|
// Class cCoreDatabase
|
|
/*=========================================================================*/
|
|
class cCoreDatabase
|
|
{
|
|
public:
|
|
// Constructor
|
|
cCoreDatabase();
|
|
|
|
// Destructor
|
|
virtual ~cCoreDatabase();
|
|
|
|
// Initialize the database - must be done once (and only once) prior
|
|
// to any database object access
|
|
virtual bool Initialize( LPCSTR pBasePath );
|
|
virtual bool Initialize();
|
|
|
|
// Exit (cleanup) the database
|
|
virtual void Exit();
|
|
|
|
// Get the entity navigation tree for the given protocol entity, if
|
|
// none exists one will be built and returned
|
|
const cDB2NavTree * GetEntityNavTree(
|
|
const std::vector <ULONG> & key ) const;
|
|
|
|
// Find the protocol entity with the specified key
|
|
bool FindEntity(
|
|
const std::vector <ULONG> & key,
|
|
sDB2ProtocolEntity & entity ) const;
|
|
|
|
// Find the protocol entity with the specified name
|
|
bool FindEntity(
|
|
LPCSTR pEntityName,
|
|
sDB2ProtocolEntity & entity ) const;
|
|
|
|
// Map a protocol entity name to an ID
|
|
bool MapEntityNameToID(
|
|
LPCSTR pName,
|
|
std::vector <ULONG> & key ) const;
|
|
|
|
// Map the given enum value (specified by enum ID, and enum value)
|
|
// to the enum value name string
|
|
std::string MapEnumToString(
|
|
ULONG enumID,
|
|
int enumVal,
|
|
bool bSimpleErrFmt = false,
|
|
bool bHex = false ) const;
|
|
|
|
// Map the given enum value (specified by enum name, and enum value)
|
|
// to the enum value name string
|
|
std::string MapEnumToString(
|
|
LPCSTR pEnumName,
|
|
int enumVal,
|
|
bool bSimpleErrFmt = false,
|
|
bool bHex = false ) const;
|
|
|
|
// (Inline) Set status log (object must exist for the duration of
|
|
// the DB or at least until being reset)
|
|
void SetLog( cDB2StatusLog * pLog )
|
|
{
|
|
if (pLog != 0)
|
|
{
|
|
mpLog = pLog;
|
|
}
|
|
};
|
|
|
|
// (Inline) Return protocol entities
|
|
const tDB2EntityMap & GetProtocolEntities() const
|
|
{
|
|
return mProtocolEntities;
|
|
};
|
|
|
|
// (Inline) Return protocol entity names
|
|
const tDB2EntityNameMap & GetProtocolEntityNames() const
|
|
{
|
|
return mEntityNames;
|
|
};
|
|
|
|
// (Inline) Return protocol structures
|
|
const tDB2FragmentMap & GetProtocolStructs() const
|
|
{
|
|
return mEntityStructs;
|
|
};
|
|
|
|
// (Inline) Return protocol fields
|
|
const tDB2FieldMap & GetProtocolFields() const
|
|
{
|
|
return mEntityFields;
|
|
};
|
|
|
|
// (Inline) Return assembled enumeration map
|
|
const tDB2EnumMap & GetEnums() const
|
|
{
|
|
return mEnumMap;
|
|
};
|
|
|
|
// (Inline) Return raw enumeration map
|
|
const tDB2EnumNameMap & GetRawEnums() const
|
|
{
|
|
return mEnumNameMap;
|
|
};
|
|
|
|
// (Inline) Return raw enumeration entry map
|
|
const tDB2EnumEntryMap & GetRawEnumEntries() const
|
|
{
|
|
return mEnumEntryMap;
|
|
};
|
|
|
|
// (Inline) Return parsed fragment modifier map - optional
|
|
const tDB2OptionalModMap & GetOptionalMods() const
|
|
{
|
|
return mOptionalModMap;
|
|
};
|
|
|
|
// (Inline) Return parsed fragment modifier map - expressions
|
|
const tDB2ExpressionModMap & GetExpressionMods() const
|
|
{
|
|
return mExpressionModMap;
|
|
};
|
|
|
|
// (Inline) Return parsed fragment modifier map - element
|
|
// count specified arrays
|
|
const tDB2Array1ModMap & GetArray1Mods() const
|
|
{
|
|
return mArray1ModMap;
|
|
};
|
|
|
|
// (Inline) Return parsed fragment modifier map - start/stop
|
|
// index specified arrays
|
|
const tDB2Array2ModMap & GetArray2Mods() const
|
|
{
|
|
return mArray2ModMap;
|
|
};
|
|
|
|
protected:
|
|
// Assemble the internal enum map
|
|
bool AssembleEnumMap();
|
|
|
|
// Assemble the internal protocol entity name map
|
|
bool AssembleEntityNameMap();
|
|
|
|
// Build the modifier tables
|
|
bool BuildModifierTables();
|
|
|
|
// Check and set the passed in path to something that is useful
|
|
std::string CheckAndSetBasePath( LPCSTR pBasePath ) const;
|
|
|
|
// Load all tables related to structure (entity, struct, field)
|
|
bool LoadStructureTables( LPCSTR pBasePath );
|
|
bool LoadStructureTables();
|
|
|
|
// Load all enumeration related tables
|
|
bool LoadEnumTables( LPCSTR pBasePath );
|
|
bool LoadEnumTables();
|
|
|
|
// Validate (and attempt repair of) structure related tables
|
|
bool ValidateStructures();
|
|
|
|
// Validate a single structure
|
|
bool ValidateStructure(
|
|
ULONG structID,
|
|
std::set <ULONG> & fields,
|
|
ULONG depth );
|
|
|
|
// Validate a single field
|
|
bool ValidateField(
|
|
ULONG structID,
|
|
ULONG fieldID,
|
|
std::set <ULONG> & fields );
|
|
|
|
// Validate an array specifier
|
|
bool ValidateArraySpecifier(
|
|
const sDB2Fragment & frag,
|
|
const std::set <ULONG> & fields );
|
|
|
|
// Validate a simple optional fragment specifier
|
|
bool ValidateOptionalSpecifier(
|
|
const sDB2Fragment & frag,
|
|
const std::set <ULONG> & fields );
|
|
|
|
// Validate a simple expression fragment specifier
|
|
bool ValidateExpressionSpecifier(
|
|
const sDB2Fragment & frag,
|
|
const std::set <ULONG> & fields );
|
|
|
|
/* Status log */
|
|
cDB2StatusLog * mpLog;
|
|
|
|
/* Protocol entity table, referenced by multi-value key */
|
|
tDB2EntityMap mProtocolEntities;
|
|
|
|
/* Protocol entity keys, referenced by indexed by entity name */
|
|
tDB2EntityNameMap mEntityNames;
|
|
|
|
/* The on-demand Protocol entity navigation map */
|
|
mutable tDB2EntityNavMap mEntityNavMap;
|
|
|
|
/* Protocol entity struct table, indexed by struct ID & fragment order */
|
|
tDB2FragmentMap mEntityStructs;
|
|
|
|
/* Protocol entity field table, indexed by field ID */
|
|
tDB2FieldMap mEntityFields;
|
|
|
|
/* Enum map, indexed by enum ID */
|
|
tDB2EnumNameMap mEnumNameMap;
|
|
|
|
/* Enum entry map, indexed by enum ID/value pair */
|
|
tDB2EnumEntryMap mEnumEntryMap;
|
|
|
|
/* The assembled enum map */
|
|
tDB2EnumMap mEnumMap;
|
|
|
|
/* Parsed fragment modifier map - optional fragments */
|
|
tDB2OptionalModMap mOptionalModMap;
|
|
|
|
/* Parsed fragment modifier map - expression fragments */
|
|
tDB2ExpressionModMap mExpressionModMap;
|
|
|
|
/* Parsed fragment modifier map - element count specified arrays */
|
|
tDB2Array1ModMap mArray1ModMap;
|
|
|
|
/* Parsed fragment modifier map - start/stop index specified arrays */
|
|
tDB2Array2ModMap mArray2ModMap;
|
|
};
|