613 lines
16 KiB
C++
613 lines
16 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 2000.
|
|
//
|
|
// File: pidmap.cxx
|
|
//
|
|
// Contents: Maps pid <--> property name.
|
|
//
|
|
// History: 31-Jan-93 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include <pidremap.hxx>
|
|
#include <coldesc.hxx>
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::CPidRemapper, public
|
|
//
|
|
// Synopsis: Creates a prop id remapper. Translates input arguments
|
|
// 'fake' propids to real propids.
|
|
//
|
|
// Arguments: [pidmap] - input prop ID mapping array
|
|
// [xPropMapper] - property mapper for real pid lookup
|
|
// [prst] - optional restriction, pids will be mapped
|
|
// [pcol] - optional output columns, pids will be mapped
|
|
// [pso] - optional sort specification, pids will be mapped
|
|
//
|
|
// History: 31-Jan-93 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
CPidRemapper::CPidRemapper( const CPidMapper & pidmap,
|
|
XInterface<IPropertyMapper> & xPropMapper,
|
|
CRestriction * prst,
|
|
CColumnSet * pcol,
|
|
CSortSet * pso )
|
|
: _xPropMapper( xPropMapper.Acquire() ),
|
|
_fAnyStatProps( FALSE ),
|
|
_fContentProp ( FALSE ),
|
|
_fRankVectorProp( FALSE ),
|
|
_cRefs( 1 )
|
|
{
|
|
_cpidReal = pidmap.Count();
|
|
_xaPidReal.Set( _cpidReal, new PROPID[ _cpidReal ] );
|
|
|
|
//
|
|
// Iterate through the list
|
|
//
|
|
|
|
for ( unsigned i = 0; i < _cpidReal; i++ )
|
|
{
|
|
PROPID pid;
|
|
FULLPROPSPEC const * pFullPropSpec = pidmap.Get(i)->CastToStruct();
|
|
SCODE sc = _xPropMapper->PropertyToPropid( pFullPropSpec, TRUE, &pid );
|
|
if ( FAILED( sc ) )
|
|
THROW( CException( sc ) );
|
|
|
|
_xaPidReal[i] = pid;
|
|
|
|
if ( IsUserDefinedPid( _xaPidReal[i] ) )
|
|
{
|
|
//
|
|
// Any user-defined property is a content property.
|
|
// Note that the document characterization is a user-defined prop.
|
|
//
|
|
_fContentProp = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if ( _xaPidReal[i] == pidContents )
|
|
_fContentProp = TRUE;
|
|
else
|
|
_fAnyStatProps = TRUE;
|
|
|
|
if ( _xaPidReal[i] == pidRankVector )
|
|
_fRankVectorProp = TRUE;
|
|
}
|
|
|
|
#if CIDBG == 1
|
|
if ( vqInfoLevel & DEB_ITRACE )
|
|
{
|
|
CFullPropSpec const & ps = *pidmap.Get(i);
|
|
|
|
GUID const & guid = ps.GetPropSet();
|
|
|
|
char szGuid[50];
|
|
|
|
sprintf( szGuid,
|
|
"%08lX-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X\\",
|
|
guid.Data1,
|
|
guid.Data2,
|
|
guid.Data3,
|
|
guid.Data4[0], guid.Data4[1],
|
|
guid.Data4[2], guid.Data4[3],
|
|
guid.Data4[4], guid.Data4[5],
|
|
guid.Data4[6], guid.Data4[7] );
|
|
|
|
vqDebugOut(( DEB_ITRACE, szGuid ));
|
|
|
|
if ( ps.IsPropertyName() )
|
|
vqDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME,
|
|
"%ws ",
|
|
ps.GetPropertyName() ));
|
|
else
|
|
vqDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME,
|
|
"0x%x ",
|
|
ps.GetPropertyPropid() ));
|
|
|
|
vqDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME, " --> pid 0x%x\n",
|
|
_xaPidReal[i] ));
|
|
|
|
}
|
|
#endif // CIDBG == 1
|
|
|
|
CFullPropSpec * ppsFull = new CFullPropSpec( *pidmap.Get(i) );
|
|
|
|
XPtr<CFullPropSpec> xpps(ppsFull);
|
|
|
|
if ( xpps.IsNull() || !xpps->IsValid() )
|
|
{
|
|
THROW( CException( STATUS_NO_MEMORY ) );
|
|
}
|
|
|
|
_propNames.Add( ppsFull, i );
|
|
xpps.Acquire();
|
|
|
|
Win4Assert( _xaPidReal[i] != pidInvalid );
|
|
}
|
|
|
|
if ( prst )
|
|
RemapPropid( prst );
|
|
|
|
if ( pcol )
|
|
RemapPropid( pcol );
|
|
|
|
if ( pso )
|
|
RemapPropid( pso );
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::CPidRemapper, public
|
|
//
|
|
// Synopsis: Creates a prop id remapper.
|
|
//
|
|
// Arguments: [xPropMapper] - Property mapper for real pid lookup
|
|
//
|
|
// History: 12-Mar-95 DwightKr Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CPidRemapper::CPidRemapper( XInterface<IPropertyMapper> & xPropMapper )
|
|
: _xPropMapper( xPropMapper.Acquire() ),
|
|
_cpidReal( 0 ),
|
|
_cRefs( 1 )
|
|
{
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::~CPidRemapper, public
|
|
//
|
|
// History: 15-Feb-93 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
CPidRemapper::~CPidRemapper()
|
|
{
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::RealToName, public
|
|
//
|
|
// Effects: Convert a PROPID to a propspec
|
|
//
|
|
// Arguments: [pid] - Given pid
|
|
//
|
|
// History: 22-Jan-97 SitaramR Added header
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
CFullPropSpec const * CPidRemapper::RealToName( PROPID pid ) const
|
|
{
|
|
Win4Assert( ! _xaPidReal.IsNull() );
|
|
|
|
//
|
|
// Just linear search
|
|
//
|
|
for ( unsigned i = 0;
|
|
i < _cpidReal && _xaPidReal[i] != pid;
|
|
i++
|
|
)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Win4Assert( i < _cpidReal );
|
|
|
|
//
|
|
// This can happen if a hacker tries to munge query requests
|
|
//
|
|
|
|
if ( i == _cpidReal )
|
|
THROW( CException( E_ABORT ) );
|
|
|
|
return( _propNames.Get( i ) );
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::NameToReal, public
|
|
//
|
|
// Effects: Convert a property which is not necessarily in the pid map
|
|
// to a PROPID.
|
|
//
|
|
// Arguments: [pProperty] - pointer to the propspec.
|
|
//
|
|
// Returns: PROPID - the mapped property ID or pidInvalid.
|
|
//
|
|
// History: 28 Jun 94 AlanW Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
PROPID CPidRemapper::NameToReal( CFullPropSpec const * pProperty )
|
|
{
|
|
for (unsigned i = 0; i < _cpidReal; i++)
|
|
{
|
|
if (*pProperty == *_propNames.Get(i))
|
|
{
|
|
return _xaPidReal[ i ];
|
|
}
|
|
}
|
|
|
|
//
|
|
// Property is not in the mapping array. Add it.
|
|
//
|
|
PROPID Prop;
|
|
FULLPROPSPEC const * pFullPropSpec = pProperty->CastToStruct();
|
|
SCODE sc = _xPropMapper->PropertyToPropid( pFullPropSpec, TRUE, &Prop );
|
|
if ( FAILED( sc ) )
|
|
THROW( CException( sc ) );
|
|
|
|
if (Prop != pidInvalid)
|
|
{
|
|
PROPID *ppidReal = new PROPID[ _cpidReal+1 ];
|
|
memcpy(ppidReal, _xaPidReal.GetPointer(), _cpidReal * sizeof (PROPID));
|
|
|
|
//
|
|
// No lock is needed here to prevent races with RealToName since in current
|
|
// usage everything is added in the query path by a single thread before
|
|
// reads happen from multiple threads.
|
|
//
|
|
|
|
PROPID *ppidTemp = _xaPidReal.Acquire();
|
|
_xaPidReal.Set( _cpidReal+1, ppidReal );
|
|
delete [] ppidTemp;
|
|
|
|
CFullPropSpec * ppsFull = new CFullPropSpec( *pProperty );
|
|
|
|
XPtr<CFullPropSpec> xpps(ppsFull);
|
|
|
|
if ( xpps.IsNull() || !xpps->IsValid() )
|
|
{
|
|
THROW( CException( STATUS_NO_MEMORY ) );
|
|
}
|
|
|
|
_propNames.Add( ppsFull, _cpidReal );
|
|
xpps.Acquire();
|
|
|
|
Win4Assert(*_propNames.Get(_cpidReal) == *pProperty);
|
|
_xaPidReal[_cpidReal] = Prop;
|
|
|
|
_cpidReal++;
|
|
}
|
|
|
|
return Prop;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::RemapPropid, public
|
|
//
|
|
// Effects: Traverses [pRst], converting 'fake' propid to 'real'
|
|
//
|
|
// Arguments: [pRst] -- Restriction
|
|
//
|
|
// History: 15-Feb-93 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CPidRemapper::RemapPropid( CRestriction * pRst )
|
|
{
|
|
Win4Assert ( pRst != 0 );
|
|
|
|
switch( pRst->Type() )
|
|
{
|
|
case RTInternalProp:
|
|
{
|
|
CInternalPropertyRestriction * pPropRst =
|
|
(CInternalPropertyRestriction *)pRst;
|
|
|
|
pPropRst->SetPid( FakeToReal( pPropRst->Pid() ) );
|
|
if ( 0 != pPropRst->GetContentHelper() )
|
|
RemapPropid( pPropRst->GetContentHelper() );
|
|
break;
|
|
}
|
|
|
|
case RTWord:
|
|
{
|
|
CWordRestriction * pWordRst = (CWordRestriction *)pRst;
|
|
pWordRst->SetPid( FakeToReal( pWordRst->Pid() ) );
|
|
break;
|
|
}
|
|
|
|
case RTSynonym:
|
|
{
|
|
CSynRestriction * pSynRst = (CSynRestriction *)pRst;
|
|
CKeyArray & keys = pSynRst->GetKeys();
|
|
|
|
for ( int i = keys.Count() - 1; i >= 0; i-- )
|
|
{
|
|
CKey & key = keys.Get(i);
|
|
key.SetPid( FakeToReal( key.Pid() ) );
|
|
}
|
|
break;
|
|
}
|
|
|
|
case RTNot:
|
|
{
|
|
CNotRestriction * pnrst = (CNotRestriction *)pRst;
|
|
|
|
RemapPropid( pnrst->GetChild() );
|
|
break;
|
|
}
|
|
|
|
case RTAnd:
|
|
case RTOr:
|
|
case RTVector:
|
|
case RTProximity:
|
|
case RTPhrase:
|
|
{
|
|
CNodeRestriction * pNodeRst = pRst->CastToNode();
|
|
|
|
for ( int i = pNodeRst->Count() - 1; i >= 0; i-- )
|
|
{
|
|
RemapPropid( pNodeRst->GetChild( i ) );
|
|
}
|
|
break;
|
|
}
|
|
case RTRange:
|
|
case RTNone: // probably a noise word in a vector query
|
|
break;
|
|
|
|
default:
|
|
Win4Assert( !"RemapPropid: Unknown type." );
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::RemapPropid, public
|
|
//
|
|
// Effects: Traverses [pColumns], converting 'fake' propid to 'real'
|
|
//
|
|
// Arguments: [pColumns] -- Output columns
|
|
//
|
|
// History: 22-Jun-93 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CPidRemapper::RemapPropid( CColumnSet * pColumns )
|
|
{
|
|
for ( unsigned i = 0; i < pColumns->Count(); i++ )
|
|
{
|
|
pColumns->Get(i) = FakeToReal( pColumns->Get(i) );
|
|
}
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPidRemapper::RemapPropid, public
|
|
//
|
|
// Effects: Traverses [pSort], converting 'fake' propid to 'real'
|
|
//
|
|
// Arguments: [pSort] -- Restriction
|
|
//
|
|
// History: 15-Feb-93 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CPidRemapper::RemapPropid( CSortSet * pSort )
|
|
{
|
|
for ( unsigned i = 0; i < pSort->Count(); i++ )
|
|
{
|
|
pSort->Get(i).pidColumn = FakeToReal( pSort->Get(i).pidColumn );
|
|
}
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------
|
|
void CPidRemapper::ReBuild( const CPidMapper & pidmap )
|
|
{
|
|
if ( _cpidReal < pidmap.Count() )
|
|
{
|
|
delete [] _xaPidReal.Acquire();
|
|
|
|
_cpidReal = 0;
|
|
|
|
_xaPidReal.Set( pidmap.Count(), new PROPID[ pidmap.Count() ] );
|
|
}
|
|
|
|
_cpidReal = pidmap.Count();
|
|
|
|
//
|
|
// Iterate through the list
|
|
//
|
|
|
|
for ( unsigned i = 0; i < _cpidReal; i++ )
|
|
{
|
|
PROPID pid;
|
|
FULLPROPSPEC const * pFullPropSpec = pidmap.Get(i)->CastToStruct();
|
|
SCODE sc = _xPropMapper->PropertyToPropid( pFullPropSpec, TRUE, &pid );
|
|
if ( FAILED( sc ) )
|
|
THROW( CException( sc ) );
|
|
|
|
_xaPidReal[i] = pid;
|
|
|
|
Win4Assert( _xaPidReal[i] != pidInvalid );
|
|
}
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------
|
|
void CPidRemapper::Set( XArray<PROPID> & aPids )
|
|
{
|
|
delete [] _xaPidReal.Acquire();
|
|
|
|
_cpidReal = aPids.Count();
|
|
_xaPidReal.Set( _cpidReal, aPids.Acquire() );
|
|
}
|
|
|
|
//
|
|
// This has to go somewhere...
|
|
//
|
|
|
|
UNICODECALLOUTS UnicodeCallouts = { WIN32_UNICODECALLOUTS };
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPidRemapper::AddRef
|
|
//
|
|
// Synopsis: Increments refcount
|
|
//
|
|
// History: 22-Jan-1997 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
ULONG STDMETHODCALLTYPE CPidRemapper::AddRef()
|
|
{
|
|
return InterlockedIncrement( (long *) &_cRefs );
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPidRemapper::Release
|
|
//
|
|
// Synopsis: Decrement refcount. Delete if necessary.
|
|
//
|
|
// History: 22-Jan-1997 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
ULONG STDMETHODCALLTYPE CPidRemapper::Release()
|
|
{
|
|
Win4Assert( _cRefs > 0 );
|
|
|
|
ULONG uTmp = InterlockedDecrement( (long *) &_cRefs );
|
|
|
|
if ( 0 == uTmp )
|
|
delete this;
|
|
|
|
return(uTmp);
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPidRemapper::QueryInterface
|
|
//
|
|
// Synopsis: Rebind to other interface
|
|
//
|
|
// Arguments: [riid] -- IID of new interface
|
|
// [ppvObject] -- New interface * returned here
|
|
//
|
|
// Returns: S_OK if bind succeeded, E_NOINTERFACE if bind failed
|
|
//
|
|
// History: 22-Jan-1997 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE STDMETHODCALLTYPE CPidRemapper::QueryInterface(
|
|
REFIID riid,
|
|
void ** ppvObject)
|
|
{
|
|
if ( IID_ICiQueryPropertyMapper == riid )
|
|
*ppvObject = (ICiQueryPropertyMapper *)this;
|
|
else if ( IID_IUnknown == riid )
|
|
*ppvObject = (IUnknown *)this;
|
|
else
|
|
{
|
|
*ppvObject = 0;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPidRemapper::PropertyToPropid
|
|
//
|
|
// Synopsis: Convert propspec to pid
|
|
//
|
|
// Arguments: [pFullPropSpec] -- propspec to convert
|
|
// [pPropId] -- pid returned here
|
|
//
|
|
// History: 22-Jan-1997 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE STDMETHODCALLTYPE CPidRemapper::PropertyToPropid( const FULLPROPSPEC *pFullPropSpec,
|
|
PROPID *pPropId)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
TRY
|
|
{
|
|
CFullPropSpec const * pProperty = (CFullPropSpec const *) pFullPropSpec;
|
|
*pPropId = NameToReal( pProperty );
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
vqDebugOut(( DEB_ERROR,
|
|
"CPidRemapper:PropertyToPropid - Exception caught 0x%x\n",
|
|
sc ));
|
|
}
|
|
END_CATCH;
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Method: CPidRemapper::PropidToProperty
|
|
//
|
|
// Synopsis: Convert pid to propspec
|
|
//
|
|
// Arguments: [pPropId] -- pid to convert
|
|
// [pFullPropSpec] -- propspec returned here
|
|
//
|
|
// Notes: *ppFullPropSpec is owned by CPidRemapper
|
|
//
|
|
// History: 22-Jan-1997 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE STDMETHODCALLTYPE CPidRemapper::PropidToProperty( PROPID propId,
|
|
FULLPROPSPEC const **ppFullPropSpec )
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
TRY
|
|
{
|
|
*ppFullPropSpec = RealToName( propId )->CastToStruct();
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
vqDebugOut(( DEB_ERROR,
|
|
"CPidRemapper:PropidToProperty - Exception caught 0x%x\n",
|
|
sc ));
|
|
}
|
|
END_CATCH;
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
|