|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1991 - 2000.
//
// File: IRest.cxx
//
// Contents: Internal (non-public) restrictions.
//
// Classes: CInternalPropertyRestriction
// COccRestriction
// CWordRestriction
// CSynRestriction
// CRangeRestriction
// CUnfilteredRestriction
// CScopeRestriction
// CPhraseRestriction
//
// History: 19-Sep-91 BartoszM Implemented.
// 29-Aug-92 MikeHew Added serialization routines
// 30-Nov-92 KyleP Removed CPhraseXpr
// 14-Jan-93 KyleP Converted from expressions
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <vkrep.hxx>
#include <norm.hxx>
#include <compare.hxx>
//+-------------------------------------------------------------------------
//
// Function: UnMarshallWideString
//
// Synopsis: Unmarshalls a wide string into a CoTaskMemAlloc'ed buffer.
// This can't be in memdeser since it calls CoTaskMemAlloc,
// which isn't available in ntdll.dll.
//
// Arguments: [stm] -- stream from which string is deserialized
//
// History: 22-Nov-95 dlee Created from a few copies
//
//--------------------------------------------------------------------------
WCHAR * UnMarshallWideString( PDeSerStream & stm ){ ULONG cc = stm.GetULong();
// Protect against attack. We know our named pipes are < 64k
if ( cc >= ( 65536 / sizeof WCHAR ) ) return 0;
XCoMem<WCHAR> xString( (WCHAR *) CoTaskMemAlloc( (cc + 1) * sizeof WCHAR ) );
if ( xString.IsNull() ) { // just eat the string
WCHAR wc[10];
while ( cc > 0 ) { if ( cc >= 10 ) { stm.GetWChar( wc, 10 ); cc -= 10; } else { stm.GetWChar( wc, cc ); cc = 0; } } } else { WCHAR * pwc = xString.GetPointer(); stm.GetWChar( pwc, cc ); pwc[cc] = 0; }
return xString.Acquire();} //UnMarshallWideString
WCHAR * UnMarshallWideStringNew( PDeSerStream & stm ){ ULONG cc = stm.GetULong();
// Protect against attack. We know our named pipes are < 64k
if ( cc >= ( 65536 / sizeof WCHAR ) ) THROW( CException( E_INVALIDARG ) );
XArray<WCHAR> xString( cc + 1 );
stm.GetWChar( xString.GetPointer(), cc ); xString[cc] = 0;
return xString.Acquire();} //UnMarshallWideStringNew
//+-------------------------------------------------------------------------
//
// Member: CInternalPropertyRestriction::CInternalPropertyRestriction
//
// Synopsis: Creates property restriction
//
// Arguments: [relop] -- Relational operator (<, >, etc.)
// [pid] -- Property id
// [prval] -- Property value
// [pcrst] -- 'Helper' content restriction
//
// History: 07-Mar-93 KyleP Created
//
//--------------------------------------------------------------------------
CInternalPropertyRestriction::CInternalPropertyRestriction( ULONG relop, PROPID pid, CStorageVariant const & prval, CRestriction * pcrst ) : CRestriction( RTInternalProp, MAX_QUERY_RANK ), _relop( relop ), _pid( pid ), _prval( prval ), _pcrst( pcrst ){ if ( !_prval.IsValid() ) THROW( CException( E_OUTOFMEMORY ) );}
//+---------------------------------------------------------------------------
//
// Member: CInternalPropertyRestriction::CInternalPropertyRestriction
//
// Synopsis: Copy constructor
//
// History: 30-May-95 SitaramR Created.
//
//----------------------------------------------------------------------------
CInternalPropertyRestriction::CInternalPropertyRestriction( CInternalPropertyRestriction const & intPropRst ) : CRestriction( RTInternalProp, intPropRst.Weight() ), _relop( intPropRst.Relation() ), _pid( intPropRst.Pid() ), _prval( intPropRst.Value() ), _pcrst( 0 ){ if ( !_prval.IsValid() ) THROW( CException( E_OUTOFMEMORY ) );
CRestriction *pHelperRst = intPropRst.GetContentHelper();
if ( pHelperRst ) _pcrst = pHelperRst->Clone();}
//+-------------------------------------------------------------------------
//
// Member: CInternalPropertyRestriction::~CInternalPropertyRestriction
//
// Synopsis: Cleanup restriction
//
// History: 01-Feb-93 KyleP Created
//
//--------------------------------------------------------------------------
CInternalPropertyRestriction::~CInternalPropertyRestriction(){ delete _pcrst;
SetType( RTNone ); // Avoid recursion.
}
void CInternalPropertyRestriction::Marshall( PSerStream & stm ) const{ stm.PutULong( _relop ); stm.PutULong( _pid ); _prval.Marshall( stm );
if ( 0 == _pcrst ) stm.PutByte( 0 ); else { stm.PutByte( 1 ); _pcrst->Marshall( stm ); }}
CInternalPropertyRestriction::CInternalPropertyRestriction( ULONG ulWeight, PDeSerStream & stm ) : CRestriction( RTInternalProp, ulWeight ), _relop( stm.GetULong() ), _pid( stm.GetULong() ), _prval( stm ){ if ( !_prval.IsValid() ) THROW( CException( E_OUTOFMEMORY ) );
BYTE fRst = stm.GetByte();
if ( fRst ) _pcrst = CRestriction::UnMarshall( stm ); else _pcrst = 0;}
//+---------------------------------------------------------------------------
//
// Member: CInternalPropertyRestriction::Clone, public
//
// Synopsis: Clones an internal property restriction
//
// History: 30-May-95 SitaramR Created.
//
//----------------------------------------------------------------------------
CInternalPropertyRestriction *CInternalPropertyRestriction::Clone() const{ return new CInternalPropertyRestriction( *this );}
//+---------------------------------------------------------------------------
//
// Member: COccRestriction::COccRestriction, public
//
// Synopsis: Creates occurrence restriction
//
// Arguments: [ulType] -- type of restriction
// [ulWeight] -- weight
// [occ] -- occurrence
// [cPrevNoiseWords] -- count of previous noise words skipped
// [cPostNoiseWords] -- count of post noise words skipped
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
COccRestriction::COccRestriction( ULONG ulType, ULONG ulWeight, OCCURRENCE occ, ULONG cPrevNoiseWords, ULONG cPostNoiseWords ) : CRestriction( ulType, ulWeight ), _occ( occ ), _cPrevNoiseWords( cPrevNoiseWords), _cPostNoiseWords( cPostNoiseWords ){}
//+-------------------------------------------------------------------------
//
// Member: COccRestriction::~COccRestriction, public
//
// Synopsis: Cleanup occurrence restriction
//
// Notes: This destructor simulates virtual destruction.
//
// Classes derived from COccRestriction must be sure to set their
// restriction type to RTNone in their destructor, so when the
// base destructor below is called the derived destructor is
// not called a second time.
//
// History: 29-Nov-94 SitaramR Created
//
//--------------------------------------------------------------------------
COccRestriction::~COccRestriction(){ switch ( Type() ) { case RTNone: break;
case RTWord: ((CWordRestriction *)this)->CWordRestriction::~CWordRestriction(); break;
case RTSynonym: ((CSynRestriction *)this)->CSynRestriction::~CSynRestriction(); break;
default: ciDebugOut(( DEB_ERROR, "Unhandled child (%d) of class COccRestriction\n", Type() )); Win4Assert( !"Unhandled child of class COccRestriction" ); break; }}
//+-------------------------------------------------------------------------
//
// Member: COccRestriction::IsValid(), public
//
// History: 14-Nov-95 KyleP Created
//
// Returns: TRUE if all memory allocations, etc. succeeded.
//
//--------------------------------------------------------------------------
BOOL COccRestriction::IsValid() const{ BOOL fValid = TRUE;
switch ( Type() ) { case RTWord: fValid = ((CWordRestriction *)this)->CWordRestriction::IsValid(); break;
case RTSynonym: fValid = ((CSynRestriction *)this)->CSynRestriction::IsValid(); break;
default: ciDebugOut(( DEB_ERROR, "Unhandled child (%d) of class COccRestriction\n", Type() )); Win4Assert( !"Unhandled child of class COccRestriction" ); fValid = FALSE; break; }
return fValid;}
//+-------------------------------------------------------------------------
//
// Member: COccRestriction::Marshall, public
//
// Synopsis: Serialize occurrence restriction
//
// Arguments: [stm] -- stream to serialize to
//
// History: 29-Nov-94 SitaramR Created
//
//--------------------------------------------------------------------------
void COccRestriction::Marshall( PSerStream& stm ) const{ stm.PutULong( _occ ); stm.PutULong( _cPrevNoiseWords ); stm.PutULong( _cPostNoiseWords ); switch ( Type() ) { case RTWord: ((CWordRestriction *)this)->Marshall( stm ); break;
case RTSynonym: ((CSynRestriction *)this)->Marshall( stm ); break;
default: ciDebugOut(( DEB_ERROR, "Unhandled child (%d) of class COccRestriction\n", Type() )); Win4Assert( !"Unhandled child of class COccRestriction" ); break;
}}
//+-------------------------------------------------------------------------
//
// Member: COccRestriction::COccRestriction, public
//
// Synopsis: De-serialize occurrence restriction
//
// Arguments: [ulType] -- type of occurrence restriction
// [ulWeight] -- weight of occurrence restriction
// [stm] -- stream to serialize from
//
// History: 29-Nov-94 SitaramR Created
//
//--------------------------------------------------------------------------
COccRestriction::COccRestriction( ULONG ulType, ULONG ulWeight, PDeSerStream& stm ) : CRestriction( ulType, ulWeight ){ _occ = stm.GetULong(); _cPrevNoiseWords = stm.GetULong(); _cPostNoiseWords = stm.GetULong();}
//+-------------------------------------------------------------------------
//
// Member: COccRestriction::Clone, public
//
// Synopsis: Clone occurrence restriction
//
// History: 29-Nov-94 SitaramR Created
//
//--------------------------------------------------------------------------
COccRestriction *COccRestriction::Clone() const{ switch ( Type() ) { case RTWord: return ((CWordRestriction *)this)->Clone(); break;
case RTSynonym: return ((CSynRestriction *)this)->Clone(); break;
default: ciDebugOut(( DEB_ERROR, "Unhandled child (%d) of class COccRestriction\n", Type() )); Win4Assert( !"Unhandled child of class COccRestriction" ); return 0; break; }}
//+---------------------------------------------------------------------------
//
// Member: CWordRestriction::CWordRestriction, public
//
// Synopsis: Creates word expression
//
// Arguments: [keyBuf] -- key to be matched
// [occ] -- occurrence (if in phrase)
// [isRange] -- TRUE if key is a prefix
//
// History: 19-Sep-91 BartoszM Created.
//
//----------------------------------------------------------------------------
CWordRestriction::CWordRestriction ( const CKeyBuf& keyBuf, OCCURRENCE occ, ULONG cPrevNoiseWords, ULONG cPostNoiseWords, BOOL isRange ) : COccRestriction( RTWord, MAX_QUERY_RANK, occ, cPrevNoiseWords, cPostNoiseWords ), _isRange(isRange){ // copy after init to 0 in case new fails and ~CWordRestriction is
// called from ~CRestriction
_key = keyBuf;}
//+---------------------------------------------------------------------------
//
// Member: CWordRestriction::CWordRestriction, public
//
// Synopsis: Copy constuctor
//
// Arguments: [wordRst] -- word restriction to be copied
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
CWordRestriction::CWordRestriction( const CWordRestriction& wordRst ) : COccRestriction( RTWord, wordRst.Weight(), wordRst.Occurrence(), wordRst.CountPrevNoiseWords(), wordRst.CountPostNoiseWords() ), _isRange( wordRst.IsRange() ){ // copy after init to 0 in case new fails and ~CWordRestriction is
// called from ~CRestriction
_key = *wordRst.GetKey();}
//+-------------------------------------------------------------------------
//
// Member: CWordRestriction::~CWordRestriction, public
//
// Synopsis: Cleanup restriction
//
// History: 01-Feb-93 KyleP Created
//
//--------------------------------------------------------------------------
CWordRestriction::~CWordRestriction(){ SetType( RTNone ); // Avoid recursion.
}
void CWordRestriction::Marshall( PSerStream & stm ) const{ _key.Marshall( stm ); stm.PutByte( (BYTE)_isRange );}
CWordRestriction::CWordRestriction( ULONG ulWeight, PDeSerStream & stm ) : COccRestriction( RTWord, ulWeight, stm ), _key( stm ), _isRange( stm.GetByte() ){}
//+---------------------------------------------------------------------------
//
// Member: CWordRestriction::Clone, public
//
// Synopsis: Clone restriction
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
CWordRestriction *CWordRestriction::Clone() const{ return new CWordRestriction( *this );}
//+---------------------------------------------------------------------------
//
// Member: CSynRestriction::CSynRestriction, public
//
// Synopsis: Creates Syn expression
//
// Arguments: [occ] -- occurrence (if in phrase)
// [isRange] -- is it range?
//
// History: 07-Feb-92 BartoszM Created.
//
//----------------------------------------------------------------------------
const int cSynonyms = 2; // default initial count of synonyms
CSynRestriction::CSynRestriction ( const CKey& key, OCCURRENCE occ, ULONG cPrevNoiseWords, ULONG cPostNoiseWords, BOOL isRange ) : COccRestriction( RTNone, MAX_QUERY_RANK, occ, cPrevNoiseWords, cPostNoiseWords ), _keyArray( cSynonyms, TRUE ), _isRange(isRange){ _keyArray.Add ( key ); SetType( RTSynonym );}
//+---------------------------------------------------------------------------
//
// Member: CSynRestriction::CSynRestriction, public
//
// Synopsis: Copy constuctor
//
// Arguments: [synRst] -- synonym restriction to be copied
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
CSynRestriction::CSynRestriction( CSynRestriction& synRst ) : COccRestriction( RTNone, synRst.Weight(), synRst.Occurrence(), synRst.CountPrevNoiseWords(), synRst.CountPostNoiseWords() ), _keyArray( synRst.GetKeys(), TRUE ), _isRange( synRst.IsRange() ){ SetType( RTSynonym );}
//+-------------------------------------------------------------------------
//
// Member: CSynRestriction::~CSynRestriction, public
//
// Synopsis: Cleanup restriction
//
// History: 01-Feb-93 KyleP Created
//
//--------------------------------------------------------------------------
CSynRestriction::~CSynRestriction(){ SetType( RTNone ); // Avoid recursion.
}
void CSynRestriction::Marshall( PSerStream & stm ) const{ _keyArray.Marshall( stm ); stm.PutByte( (BYTE)_isRange );}
CSynRestriction::CSynRestriction( ULONG ulWeight, PDeSerStream & stm ) : COccRestriction( RTNone, ulWeight, stm), _keyArray( stm, TRUE ), _isRange( stm.GetByte() ){ SetType( RTSynonym );}
//+---------------------------------------------------------------------------
//
// Member: CSynRestriction::Clone, public
//
// Synopsis: Clone restriction
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
CSynRestriction *CSynRestriction::Clone() const{ return new CSynRestriction( *(CSynRestriction *)this );}
//+---------------------------------------------------------------------------
//
// Member: CSynRestriction::AddKey, public
//
// Synopsis: Adds synonym key
//
// Arguments: [keyBuf] -- key
//
// History: 07-Feb-92 BartoszM Created.
//
//----------------------------------------------------------------------------
void CSynRestriction::AddKey ( const CKeyBuf& Key ){ _keyArray.Add ( Key );}
//+---------------------------------------------------------------------------
//
// Member: CRangeRestriction::CRangeRestriction, public
//
// Synopsis: Creates word expression
//
// Arguments: [pid] -- property id
// [keyStart] -- starting key
// [keyEnd] -- ending key
//
// History: 24-Sep-92 BartoszM Created.
//
//----------------------------------------------------------------------------
CRangeRestriction::CRangeRestriction() : CRestriction( RTRange, MAX_QUERY_RANK ){}
//+---------------------------------------------------------------------------
//
// Member: CRangeRestriction::CRangeRestriction
//
// Synopsis: Copy constructor
//
// History: 30-May-95 SitaramR Created
//
//----------------------------------------------------------------------------
CRangeRestriction::CRangeRestriction( const CRangeRestriction& rangeRst ) : CRestriction( RTNone, rangeRst.Weight() ){ const CKey *pKeyStart = rangeRst.GetStartKey();
if ( pKeyStart ) _keyStart = *pKeyStart;
const CKey *pKeyEnd = rangeRst.GetEndKey();
if ( pKeyEnd ) _keyEnd = *pKeyEnd;
SetType( RTRange );}
//+-------------------------------------------------------------------------
//
// Member: CRangeRestriction::~CRangeRestriction, public
//
// Synopsis: Cleanup restriction
//
// History: 01-Feb-93 KyleP Created
//
//--------------------------------------------------------------------------
CRangeRestriction::~CRangeRestriction(){ SetType( RTNone ); // Avoid recursion.
}
void CRangeRestriction::Marshall( PSerStream & stm ) const{ _keyStart.Marshall( stm ); _keyEnd.Marshall( stm );}
CRangeRestriction::CRangeRestriction( ULONG ulWeight, PDeSerStream & stm ) : CRestriction( RTNone, ulWeight ), _keyStart( stm ), _keyEnd( stm ){ SetType( RTRange );}
//+---------------------------------------------------------------------------
//
// Member: CRangeRestriction::SetStartKey, public
//
// Arguments: [keyStart] -- starting key
//
// History: 24-Sep-92 BartoszM Created.
//
//----------------------------------------------------------------------------
void CRangeRestriction::SetStartKey ( const CKeyBuf& keyStart ){ _keyStart = keyStart;}
//+---------------------------------------------------------------------------
//
// Member: CRangeRestriction::SetEndKey, public
//
// Arguments: [keyEnd] -- Ending key
//
// History: 24-Sep-92 BartoszM Created.
//
//----------------------------------------------------------------------------
void CRangeRestriction::SetEndKey ( const CKeyBuf& keyEnd ){ _keyEnd = keyEnd;}
//+---------------------------------------------------------------------------
//
// Member: CRangeRestriction::Clone
//
// Synopsis: Clones a range restriction
//
// History: 30-May-95 SitaramR Created
//
//----------------------------------------------------------------------------
CRangeRestriction *CRangeRestriction::Clone() const{ return new CRangeRestriction( *this );}
//+---------------------------------------------------------------------------
//
// Member: CUnfilteredRestriction::CUnfilteredRestriction, public
//
// History: 10-Nov-94 KyleP Created.
//
// Notes: This restriction is just a very special case of range
// restriction that searches only for a particular value.
// Standard procedure to create a range restriction is
// sidetracked to save code.
//
//----------------------------------------------------------------------------
CUnfilteredRestriction::CUnfilteredRestriction(){ static const BYTE abUnfiltered[] = { VT_UI1, (BYTE)(pidUnfiltered >> 24), (BYTE)(pidUnfiltered >> 16), (BYTE)(pidUnfiltered >> 8), (BYTE) pidUnfiltered, 0, 1 };
static CKeyBuf keyUnfilteredRange( pidUnfiltered, abUnfiltered, sizeof(abUnfiltered) );
SetStartKey( keyUnfilteredRange ); SetEndKey( keyUnfilteredRange );
#if DBG == 1 && CIDBG == 1
CRangeKeyRepository krep; CValueNormalizer norm( krep ); OCCURRENCE occ = 1; CStorageVariant var; var.SetBOOL( (VARIANT_BOOL)0xFFFF );
norm.PutValue( pidUnfiltered, occ, var ); norm.PutValue( pidUnfiltered, occ, var );
CRestriction * prst = krep.AcqRst();
Win4Assert( prst->Type() == RTRange );
CRangeRestriction * pRange = (CRangeRestriction *)prst;
Win4Assert( pRange->GetStartKey()->Compare( *GetStartKey() ) == 0 ); Win4Assert( pRange->GetEndKey()->Compare( *GetEndKey() ) == 0 );
delete prst;#endif
}
//+---------------------------------------------------------------------------
//
// Member: CPhraseRestriction::CPhraseRestriction, public
//
// Synopsis: Deserializes phrase restriction
//
// Arguments: [ulWeight] -- restriction weight
// [stm] -- stream to deserialize from
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
CPhraseRestriction::CPhraseRestriction( ULONG ulWeight, PDeSerStream& stm ) : CNodeRestriction( RTPhrase, ulWeight, stm ){#if CIDBG == 1
for ( unsigned i = 0; i < _cNode; i++ ) Win4Assert( _paNode[i]->Type() == RTWord || _paNode[i]->Type() == RTSynonym );#endif
}
//+---------------------------------------------------------------------------
//
// Member: CPhraseRestriction::~CPhraseRestriction, public
//
// History: 29-Nov-94 SitaramR Created.
//
//----------------------------------------------------------------------------
CPhraseRestriction::~CPhraseRestriction(){ if ( 0 != _paNode ) { for ( unsigned i = 0; i < _cNode; i++ ) { #if CIDBG == 1
if ( 0 != _paNode[i] ) { Win4Assert( _paNode[i]->Type() == RTWord || _paNode[i]->Type() == RTSynonym ); } #endif // CIDBG
delete (COccRestriction *) _paNode[i]; }
delete [] _paNode; }
SetType( RTNone ); // Avoid recursion.
}
CScopeRestriction::CScopeRestriction( WCHAR const * pwcsPath, BOOL fRecursive, BOOL fVirtual ) : CRestriction( RTScope, MAX_QUERY_RANK ), _fValid( FALSE ), _fRecursive( fRecursive ), _fVirtual( fVirtual ){ SetPath( pwcsPath );}
CScopeRestriction * CScopeRestriction::Clone() const{ return( new CScopeRestriction( _lowerFunnyPath.GetActualPath(), _fRecursive, _fVirtual ) );}
CScopeRestriction::~CScopeRestriction(){ SetType( RTNone ); // Avoid recursion.
}
void CScopeRestriction::Marshall( PSerStream & stm ) const{ stm.PutWString( _lowerFunnyPath.GetActualPath() ); stm.PutULong( _lowerFunnyPath.GetActualLength() ); stm.PutULong( _fRecursive ); stm.PutULong( _fVirtual );}
CScopeRestriction::CScopeRestriction( ULONG ulWeight, PDeSerStream & stm ) : CRestriction( RTScope, ulWeight ), _fValid( FALSE ){ XCoMem<WCHAR> xString( UnMarshallWideString( stm ) );
//
// Simple validity checks; not all-inclusive. Just
// return with _fValid set to FALSE and the query
// will fail with an out of memory error.
//
// We don't support long paths for scopes.
if ( wcslen( xString.GetPointer() ) >= MAX_PATH ) return;
// We don't support the NTFS special stream syntax
if ( 0 != wcsstr( xString.GetPointer(), L"::$" ) ) return;
stm.GetULong(); // length not needed
_fRecursive = stm.GetULong(); _fVirtual = stm.GetULong(); _lowerFunnyPath.SetPath( xString.Acquire() ); _fValid = TRUE; // since we have a valid path
}
CScopeRestriction & CScopeRestriction::operator =( CScopeRestriction const & source ){ _lowerFunnyPath = source._lowerFunnyPath; _fRecursive = source._fRecursive; _fVirtual = source._fVirtual; _fValid = source._fValid;
return *this;}
//+---------------------------------------------------------------------------
//
// Method: CScopeRestriction::SetPath
//
// Synopsis: Validates and sets a path in a scope restriction
//
// History: 24-Oct-96 dlee Created.
//
//----------------------------------------------------------------------------
void CScopeRestriction::SetPath( WCHAR const * pwcsPath ){ _fValid = FALSE;
//
// Simple validity checks; not all-inclusive. Just
// return with _fValid set to FALSE and the query
// wil fail with an out of memory error.
//
// We don't support long paths for scopes.
if ( wcslen( pwcsPath ) >= MAX_PATH ) return;
// We don't support the NTFS special stream syntax
if ( 0 != wcsstr( pwcsPath, L"::$" ) ) return;
_lowerFunnyPath.Truncate(0); if ( pwcsPath) { _lowerFunnyPath.SetPath( pwcsPath ); _fValid = TRUE; }} //SetPath
//+---------------------------------------------------------------------------
//
// Function: ValidateScopeRestriction
//
// Synopsis: Verifies a scope restriction looks ok. Can't use
// CRestriction::IsValid since this needs to make sure there
// aren't any odd nodes in the tree (like proximity, etc.)
//
// Returns: TRUE if it is ok, FALSE otherwise
//
// History: 24-Oct-96 dlee Created.
//
//----------------------------------------------------------------------------
BOOL ValidateScopeRestriction( CRestriction * pRst ){ if ( 0 == pRst ) return FALSE;
switch ( pRst->Type() ) {#if 0 // someday we might support exclusion scopes
case RTNot: { CRestriction *p = ((CNotRestriction *)pRst)->GetChild(); return ValidateScopeRestriction( p ); break; } case RTAnd:#endif // 0 // exclusion scopes
case RTOr: { CNodeRestriction * p = pRst->CastToNode(); for ( ULONG x = 0; x < p->Count(); x++ ) { if ( !ValidateScopeRestriction( p->GetChild( x ) ) ) return FALSE; } break; } case RTScope: { CScopeRestriction *p = (CScopeRestriction *) pRst; if ( !p->IsValid() ) return FALSE; break; } default : { return FALSE; } }
return TRUE;} //ValidateScopeRestriction
#if CIDBG == 1
//+-------------------------------------------------------------------------
//
// Function: DisplayChar
//
// Synopsis: Debug print the non-ascii text buffer
//
// Arguments: [pwString] -- Pointer to string (not null terminated)
// [cString] -- len of the string in char
// [infolevel] --
//
// History: 22-Apr-98 KitmanH Created
//
//--------------------------------------------------------------------------
void DisplayChar( WCHAR * pwString, DWORD cString, ULONG infolevel ){
BOOL fOk = TRUE; for ( unsigned i = 0; i < cString; i++ ) { if ( pwString[i] > 0xFF ) { fOk = FALSE; break; } }
if ( fOk ) { unsigned j = 0; WCHAR awcTemp[71];
for ( unsigned i = 0; i < cString; i++ ) { awcTemp[j] = pwString[i]; j++;
if ( j == sizeof(awcTemp)/sizeof(awcTemp[0]) - 1 ) { awcTemp[j] = 0; vqDebugOut(( infolevel | DEB_NOCOMPNAME, "\"%ws\"", awcTemp )); j = 0; } }
awcTemp[j] = 0; vqDebugOut(( infolevel | DEB_NOCOMPNAME, "\"%ws\"", awcTemp )); } else { vqDebugOut(( infolevel | DEB_NOCOMPNAME, "0x" ));
unsigned j = 0;
for ( unsigned i = 0; i < cString; i++ ) { if ( 0 == j ) vqDebugOut(( infolevel | DEB_NOCOMPNAME, "%04X", pwString[i] )); else if ( 14 == j ) { vqDebugOut(( infolevel | DEB_NOCOMPNAME, " %04X\n", pwString[i] )); } else vqDebugOut(( infolevel | DEB_NOCOMPNAME, " %04X", pwString[i] ));
j++;
if ( j > 14 ) j = 0; }
}
}
void Display( CRestriction * pRst, int indent, ULONG infolevel ){ vqDebugOut(( infolevel, " " ));
for ( int i = 0; i < indent; i++ ) { vqDebugOut(( infolevel | DEB_NOCOMPNAME, " " )); }
switch ( pRst->Type() ) { case RTContent: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "CONTENT: \"%ws\", LOCALE: %lu\n", ((CContentRestriction *)pRst)->GetPhrase(), ((CContentRestriction *)pRst)->GetLocale() )); break;
case RTNatLanguage: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "NATURAL LANGUAGE: \"%ws\", LOCALE: %lu\n", ((CNatLanguageRestriction *)pRst)->GetPhrase(), ((CNatLanguageRestriction *)pRst)->GetLocale() )); break;
case RTWord: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "WORD%s: ", ((CWordRestriction *)pRst)->IsRange() ? " PREFIX" : "" )); DisplayChar( ((CWordRestriction *)pRst)->GetKey()->GetStr(), ((CWordRestriction *)pRst)->GetKey()->StrLen(), infolevel );
vqDebugOut(( infolevel | DEB_NOCOMPNAME, " PID %d OCC %d, WEIGHT %d\n", ((CWordRestriction *)pRst)->Pid(), ((CWordRestriction *)pRst)->Occurrence(), ((CWordRestriction *)pRst)->Weight() )); break;
case RTSynonym: { vqDebugOut(( infolevel | DEB_NOCOMPNAME, "SYNONYM: OCC %d ", ((CSynRestriction *)pRst)->Occurrence() )); CKeyArray & keys = ((CSynRestriction *)pRst)->GetKeys();
for ( int i = 0; i < keys.Count(); i++ ) { DisplayChar( keys.Get(i).GetStr(), keys.Get(i).StrLen(), infolevel ); vqDebugOut(( infolevel | DEB_NOCOMPNAME, " " )); } vqDebugOut(( infolevel | DEB_NOCOMPNAME, "\n" )); break; }
case RTRange: { CRangeRestriction * pr = (CRangeRestriction *)pRst;
vqDebugOut(( infolevel | DEB_NOCOMPNAME, "RANGE: " ));
char * pc = new char[pr->GetStartKey()->Count() * 2 + 1 + pr->GetEndKey()->Count() * 2 + 2];
for ( unsigned i = 0; i < pr->GetStartKey()->Count(); i++ ) sprintf( pc + i*2, "%02x", pr->GetStartKey()->GetBuf()[i] );
pc[i*2] = '-';
for ( unsigned j = 0; j < pr->GetEndKey()->Count(); j++ ) sprintf( pc + i*2 + 1 + j*2, "%02x", pr->GetEndKey()->GetBuf()[j] );
pc[i*2 + 1 + j*2] = '\n'; pc[i*2 + 1 + j*2 + 1] = 0; vqDebugOut(( infolevel | DEB_NOCOMPNAME, pc )); delete [] pc; break; }
case RTProperty: if ( ((CPropertyRestriction *)pRst)->Relation() == PRRE ) vqDebugOut(( infolevel | DEB_NOCOMPNAME, "REGEX " )); else vqDebugOut(( infolevel | DEB_NOCOMPNAME, "PROPERTY " ));
((CPropertyRestriction *) pRst)->Value().DisplayVariant( infolevel | DEB_NOCOMPNAME, 0); vqDebugOut(( infolevel | DEB_NOCOMPNAME, "\n" )); break;
case RTInternalProp: { CInternalPropertyRestriction * pir = (CInternalPropertyRestriction *)pRst;
if ( pir->Relation() == PRRE ) vqDebugOut(( infolevel | DEB_NOCOMPNAME, "REGEX pid(0x%lx) ", pir->Pid() )); else { vqDebugOut(( infolevel | DEB_NOCOMPNAME, "PROPERTY pid(0x%lx) ", pir->Pid() )); switch ( getBaseRelop( pir->Relation() ) ) { case PRLT: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "< " )); break;
case PRLE: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "<= " )); break;
case PRGT: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "> " )); break;
case PRGE: vqDebugOut(( infolevel | DEB_NOCOMPNAME, ">= " )); break;
case PREQ: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "== " )); break;
case PRNE: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "!= " )); break;
case PRAllBits: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "All bits " )); break;
case PRSomeBits: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "Some bits " )); break;
default: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "??? " )); break; }
if ( pir->Relation() & PRAll ) vqDebugOut(( infolevel | DEB_NOCOMPNAME, "All " )); else if ( pir->Relation() & PRAny ) vqDebugOut(( infolevel | DEB_NOCOMPNAME, "Any " ));
}
pir->Value().DisplayVariant(infolevel | DEB_NOCOMPNAME, 0);
if ( pir->GetContentHelper() ) { vqDebugOut(( infolevel | DEB_NOCOMPNAME, "\n" ));
for ( int i = 0; i < indent+5; i++ ) { vqDebugOut(( infolevel | DEB_NOCOMPNAME, " " )); } vqDebugOut(( infolevel | DEB_NOCOMPNAME, "HELPER:\n" )); Display( pir->GetContentHelper(), indent+3, infolevel ); } vqDebugOut(( infolevel | DEB_NOCOMPNAME, "\n" )); break; }
case RTNot: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "NOT\n" )); Display( ((CNotRestriction *)pRst)->GetChild(), indent + 1, infolevel ); break;
case RTAnd: case RTOr: case RTProximity: case RTVector: case RTPhrase: { switch( pRst->Type() ) { case RTAnd: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "AND\n" )); break;
case RTOr: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "OR\n" )); break;
case RTNot: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "NOT\n" )); break;
case RTProximity: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "PROXIMITY\n" )); break;
case RTVector: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "VECTOR " )); switch ( ((CVectorRestriction *)pRst)->RankMethod() ) { case VECTOR_RANK_MIN: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "(Min)\n" )); break;
case VECTOR_RANK_MAX: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "(Max)\n" )); break;
case VECTOR_RANK_INNER: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "(Inner Product)\n" )); break;
case VECTOR_RANK_DICE: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "(Dice Coefficient)\n" )); break;
case VECTOR_RANK_JACCARD: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "(Jaccard Coefficient)\n" )); break;
default: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "(???)\n" )); break; } break;
case RTPhrase: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "PHRASE\n" )); break; }
CNodeRestriction * pNodeRst = pRst->CastToNode();
for ( UINT i = 0; i < pNodeRst->Count(); i++ ) { Display( pNodeRst->GetChild( i ), indent + 1, infolevel ); } break; }
case RTNone: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "NONE -- empty\n" )); break;
default: vqDebugOut(( infolevel | DEB_NOCOMPNAME, "UNKNOWN\n" )); break;
}}
#endif // CIDBG == 1
|
