Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
NT4/public/sdk/inc/restrict.hxx

1663 lines
32 KiB
C++
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1992.
//
// File: Restrict.hxx
//
// Contents: C++ wrapper(s) for restrictions.
//
// History: 31-Dec-93 KyleP Created
// 28-Jul-94 KyleP Hand marshalling
// 05-Apr-95 t-ColinB Added a SetValue to CPropertyRestriction
//
// Notes: These C++ wrappers are a bit of a hack. They are
// dependent on the layout of the matching C structures.
// Inheritance from C structures cannot be used directly
// because MIDL doesn't support C++ style inheritance,
// and these structures are defined along with their
// respective Ole interfaces in .idl files.
//
// No virtual methods (even virtual destructors) are
// allowed because they change the layout of the class
// in C++. Luckily, the class hierarchies below are
// quite flat. Virtual methods are simulated with
// switch statements in parent classes.
//
// In C, all structures must be allocated via CoTaskMemAlloc.
// This is the only common allocator for Ole.
//
//--------------------------------------------------------------------------
#if !defined( __RESTRICT_HXX__ )
#define __RESTRICT_HXX__
#include <query.h>
#include <stgvar.hxx>
//
// The OFFSETS_MATCH macro is used to verify structure offsets between
// C++ structures and their corresponding C structures. 0 Cannot be used
// as pointer because of special treatment of casts to 0 in C++
//
#define OFFSETS_MATCH( class1, field1, class2, field2 ) \
( (int)&((class1 *)10)->field1 == \
(int)&((class2 *)10)->field2 )
//
// Forward declarations
//
class CNodeRestriction;
class PSerStream;
class PDeSerStream;
//+-------------------------------------------------------------------------
//
// Class: CFullPropertySpec
//
// Purpose: Describes full (PropertySet\Property) name of a property.
//
// History: 08-Jan-93 KyleP Created
//
//--------------------------------------------------------------------------
class CFullPropSpec
{
public:
//
// Constructors
//
CFullPropSpec();
CFullPropSpec( GUID const & guidPropSet, PROPID pidProperty );
CFullPropSpec( GUID const & guidPropSet, WCHAR const * wcsProperty );
//
// Validity check
//
inline BOOL IsValid() const;
//
// Copy constructors/assignment/clone
//
CFullPropSpec( CFullPropSpec const & Property );
CFullPropSpec & operator=( CFullPropSpec const & Property );
//
// Destructor
//
~CFullPropSpec();
//
// Memory allocation
//
void * operator new( size_t size );
inline void * operator new( size_t size, void * p );
void operator delete( void * p );
//
// C/C++ conversion
//
inline FULLPROPSPEC * CastToStruct();
inline FULLPROPSPEC const * CastToStruct() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CFullPropSpec( PDeSerStream & stm );
//
// Comparators
//
int operator==( CFullPropSpec const & prop ) const;
int operator!=( CFullPropSpec const & prop ) const;
//
// Member variable access
//
inline void SetPropSet( GUID const & guidPropSet );
inline GUID const & GetPropSet() const;
void SetProperty( PROPID pidProperty );
BOOL SetProperty( WCHAR const * wcsProperty );
inline WCHAR const * GetPropertyName() const;
inline PROPID GetPropertyPropid() const;
inline PROPSPEC GetPropSpec() const;
inline BOOL IsPropertyName() const;
inline BOOL IsPropertyPropid() const;
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
GUID _guidPropSet;
PROPSPEC _psProperty;
};
inline
int CFullPropSpec::operator==( CFullPropSpec const & prop ) const
{
if ( prop._psProperty.ulKind != _psProperty.ulKind )
return 0;
switch( _psProperty.ulKind )
{
case PRSPEC_PROPID:
if ( GetPropertyPropid() != prop.GetPropertyPropid() )
return 0;
break;
case PRSPEC_LPWSTR:
if ( _wcsicmp( GetPropertyName(), prop.GetPropertyName() ) != 0 )
return 0;
break;
default:
return 0;
}
return prop._guidPropSet == _guidPropSet;
}
inline
int CFullPropSpec::operator!=( CFullPropSpec const & prop ) const
{
if (*this == prop)
return( 0 );
else
return( 1 );
}
inline
CFullPropSpec::~CFullPropSpec()
{
if ( _psProperty.ulKind == PRSPEC_LPWSTR &&
_psProperty.lpwstr )
{
CoTaskMemFree( _psProperty.lpwstr );
}
}
inline void * operator new( size_t size, void * p )
{
return( p );
}
//+-------------------------------------------------------------------------
//
// Member: CFullPropSpec::CFullPropSpec, public
//
// Synopsis: Construct name based propspec
//
// Arguments: [guidPropSet] -- Property set
// [wcsProperty] -- Property
//
// History: 22-Jun-93 KyleP Created
//
//--------------------------------------------------------------------------
inline
CFullPropSpec::CFullPropSpec( GUID const & guidPropSet,
WCHAR const * wcsProperty )
: _guidPropSet( guidPropSet )
{
_psProperty.ulKind = PRSPEC_PROPID;
SetProperty( wcsProperty );
}
//+-------------------------------------------------------------------------
//
// Member: CFullPropSpec::CFullPropSpec, public
//
// Synopsis: Construct propid based propspec
//
// Arguments: [guidPropSet] -- Property set
// [pidProperty] -- Property
//
// History: 22-Jun-93 KyleP Created
//
//--------------------------------------------------------------------------
inline
CFullPropSpec::CFullPropSpec( GUID const & guidPropSet, PROPID pidProperty )
: _guidPropSet( guidPropSet )
{
_psProperty.ulKind = PRSPEC_PROPID;
_psProperty.propid = pidProperty;
}
//+-------------------------------------------------------------------------
//
// Member: CFullPropSpec::CFullPropSpec, public
//
// Synopsis: Default constructor
//
// Effects: Defines property with null guid and propid 0
//
// History: 22-Jun-93 KyleP Created
//
//--------------------------------------------------------------------------
inline
CFullPropSpec::CFullPropSpec()
{
RtlZeroMemory( &_guidPropSet, sizeof(_guidPropSet) );
_psProperty.ulKind = PRSPEC_PROPID;
_psProperty.propid = 0;
}
//+-------------------------------------------------------------------------
//
// Member: CFullPropSpec::operator=, public
//
// Synopsis: Assignment operator
//
// Arguments: [Property] -- Source property
//
// History: 17-Jul-93 KyleP Created
//
//--------------------------------------------------------------------------
inline
CFullPropSpec & CFullPropSpec::operator=( CFullPropSpec const & Property )
{
//
// Clean up.
//
CFullPropSpec::~CFullPropSpec();
new (this) CFullPropSpec( Property );
return *this;
}
//+-------------------------------------------------------------------------
//
// Class: CColumns
//
// Purpose: C++ wrapper for COLUMNSET
//
// History: 22-Jun-93 KyleP Created
//
//--------------------------------------------------------------------------
class CColumns
{
public:
//
// Constructors
//
CColumns( unsigned size = 0 );
//
// Copy constructors/assignment/clone
//
CColumns( CColumns const & src );
CColumns & operator=( CColumns const & src );
//
// Destructor
//
~CColumns();
//
// Memory allocation
//
void * operator new( size_t size );
void operator delete( void * p );
//
// Validity check
//
inline BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CColumns( PDeSerStream & stm );
//
// C/C++ conversion
//
inline COLUMNSET * CastToStruct();
//
// Member variable access
//
BOOL Add( CFullPropSpec const & Property, unsigned pos );
void Remove( unsigned pos );
inline CFullPropSpec const & Get( unsigned pos ) const;
inline unsigned Count() const;
private:
unsigned _cCol;
CFullPropSpec * _aCol;
unsigned _size;
};
//+-------------------------------------------------------------------------
//
// Structure: SortKey
//
// Purpose: wraper for SORTKEY class
//
//--------------------------------------------------------------------------
class CSortKey
{
public:
//
// Constructors
//
inline CSortKey();
inline CSortKey( CFullPropSpec const & ps, ULONG dwOrder );
inline CSortKey( CFullPropSpec const & ps, ULONG dwOrder, LCID locale );
//
// Memory allocation
//
void * operator new( size_t size );
void operator delete( void * p );
//
// Validity check
//
inline BOOL IsValid() const;
//
// Member variable access
//
inline void SetProperty( CFullPropSpec const & ps );
inline CFullPropSpec const & GetProperty() const;
inline ULONG GetOrder() const;
inline LCID GetLocale() const;
inline void SetLocale(LCID locale);
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CSortKey( PDeSerStream & stm );
private:
CFullPropSpec _property;
ULONG _dwOrder;
LCID _locale;
};
//+-------------------------------------------------------------------------
//
// Class: CSort
//
// Purpose: C++ wrapper for SORTSET
//
// History: 22-Jun-93 KyleP Created
//
//--------------------------------------------------------------------------
class CSort
{
public:
//
// Constructors
//
CSort( unsigned size = 0 );
//
// Copy constructors/assignment/clone
//
CSort( CSort const & src );
CSort & operator=( CSort const & src );
//
// Destructor
//
~CSort();
//
// Memory allocation
//
inline void * operator new( size_t size );
inline void operator delete( void * p );
//
// Validity check
//
inline BOOL IsValid() const;
//
// C/C++ conversion
//
inline SORTSET * CastToStruct();
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CSort( PDeSerStream & stm );
//
// Member variable access
//
BOOL Add( CSortKey const &sk, unsigned pos );
BOOL Add( CFullPropSpec const & Property, ULONG dwOrder, unsigned pos );
void Remove( unsigned pos );
inline CSortKey const & Get( unsigned pos ) const;
inline unsigned Count() const;
private:
unsigned _csk;
CSortKey * _ask;
unsigned _size;
};
//+-------------------------------------------------------------------------
//
// Class: CRestriction
//
// Purpose: Base restriction class
//
// History: 31-Dec-93 KyleP Created
//
//--------------------------------------------------------------------------
class CRestriction
{
public:
//
// Constructors
//
inline CRestriction();
inline CRestriction( ULONG RestrictionType, ULONG ulWeight );
//
// Copy constructors/assigment/clone
//
CRestriction * Clone();
//
// Destructor
//
~CRestriction();
//
// Memory allocation
//
void * operator new( size_t size );
void operator delete( void * p );
//
// Validity check
//
BOOL IsValid() const;
//
// C/C++ conversion
//
inline RESTRICTION * CastToStruct() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
static CRestriction * UnMarshall( PDeSerStream & stm );
//
// Member variable access
//
inline ULONG Type() const;
inline ULONG Weight() const;
inline void SetWeight( ULONG ulWeight );
inline CNodeRestriction * CastToNode() const;
BOOL IsLeaf() const;
ULONG TreeCount() const;
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
protected:
inline void SetType( ULONG RestrictionType );
private:
ULONG _ulType;
ULONG _ulWeight;
};
//+-------------------------------------------------------------------------
//
// Class: CNodeRestriction
//
// Purpose: Boolean AND/OR/VECTOR restriction
//
// History: 31-Dec-93 KyleP Created
//
//--------------------------------------------------------------------------
class CNodeRestriction : public CRestriction
{
public:
//
// Constructors
//
CNodeRestriction( ULONG NodeType, unsigned cInitAllocated = 2 );
//
// Copy constructors/assignment/clone
//
CNodeRestriction( const CNodeRestriction& nodeRst );
CNodeRestriction * Clone();
//
// Destructor
//
~CNodeRestriction();
//
// Validity check
//
BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CNodeRestriction( ULONG ulType, ULONG ulWeight, PDeSerStream & stm );
//
// Node manipulation
//
BOOL AddChild( CRestriction * presChild, unsigned & pos );
inline BOOL AddChild( CRestriction * presChild );
CRestriction * RemoveChild( unsigned pos );
//
// Member variable access
//
inline void SetChild( CRestriction * presChild, unsigned pos );
inline CRestriction * GetChild( unsigned pos ) const;
inline unsigned Count() const;
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
BOOL Grow();
protected:
ULONG _cNode;
CRestriction ** _paNode;
//
// Members mapped to C structure end here. The following will
// be reserved in the C structure to maintain to C <--> C++
// facade.
//
ULONG _cNodeAllocated;
};
//+-------------------------------------------------------------------------
//
// Class: CNotRestriction
//
// Purpose: Boolean AND/OR/VECTOR restriction
//
// History: 31-Dec-93 KyleP Created
//
//--------------------------------------------------------------------------
class CNotRestriction : public CRestriction
{
public:
//
// Constructors
//
inline CNotRestriction();
inline CNotRestriction( CRestriction * pres );
CNotRestriction( CNotRestriction& notRst );
CNotRestriction *Clone();
//
// Destructor
//
~CNotRestriction();
//
// Validity check
//
inline BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CNotRestriction( ULONG ulWeight, PDeSerStream & stm );
//
// Node manipulation
//
inline void SetChild( CRestriction * pres );
inline CRestriction * GetChild();
inline CRestriction * RemoveChild();
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
CRestriction * _pres;
};
//+-------------------------------------------------------------------------
//
// Class: CVectorRestriction
//
// Purpose: Extended boolean (vector) restriction
//
// History: 08-Jan-93 KyleP Created
//
//--------------------------------------------------------------------------
class CVectorRestriction : public CNodeRestriction
{
public:
//
// Constructors
//
inline CVectorRestriction( ULONG ulRankMethod,
unsigned cInitAllocated = 128 );
//
// Copy constructors/assignment/clone
//
inline CVectorRestriction( CVectorRestriction& vecRst );
CVectorRestriction * Clone();
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CVectorRestriction( ULONG ulWeight, PDeSerStream & stm );
//
// Member variable access
//
inline void SetRankMethod( ULONG ulRankMethod );
inline ULONG RankMethod() const;
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
ULONG _ulRankMethod;
};
//+-------------------------------------------------------------------------
//
// Class: CContentRestriction
//
// Purpose: Scope restriction
//
// History: 07-Jan-93 KyleP Created
//
//--------------------------------------------------------------------------
class CContentRestriction : public CRestriction
{
public:
//
// Constructors
//
CContentRestriction( WCHAR const * pwcsPhrase,
CFullPropSpec const & Property,
ULONG ulFuzzy = 0,
LCID lcid = GetSystemDefaultLCID() );
CContentRestriction( CContentRestriction& contentRst );
//
// Copy constructors/assignment/clone
//
CContentRestriction * Clone();
//
// Destructor
//
~CContentRestriction();
//
// Validity check
//
inline BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CContentRestriction( ULONG ulWeight, PDeSerStream & stm );
//
// Member variable access
//
void SetPhrase( WCHAR const * pwcsPhrase );
inline WCHAR const * GetPhrase() const;
inline void SetProperty( CFullPropSpec const & Property );
inline CFullPropSpec const & GetProperty() const;
LCID GetLocale() const { return _lcid; }
inline void SetFuzzyLevel( ULONG ulFuzzy );
inline ULONG FuzzyLevel();
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
CFullPropSpec _Property; // Property Name
WCHAR * _pwcsPhrase; // content
LCID _lcid;
ULONG _ulFuzzyLevel; // Fuzzy search level.
};
//+-------------------------------------------------------------------------
//
// Class: CComplexContentRestriction
//
// Purpose: Supports scaffolding query language
//
// History: 08-Jan-93 KyleP Created
//
//--------------------------------------------------------------------------
class CComplexContentRestriction : public CRestriction
{
public:
//
// Constructors
//
CComplexContentRestriction( WCHAR * pwcsExpression,
LCID lcid = GetSystemDefaultLCID() );
CComplexContentRestriction( const CComplexContentRestriction& compRst );
//
// Copy constructors/assignment/clone
//
CComplexContentRestriction * Clone();
//
// Destructors
//
~CComplexContentRestriction();
//
// Validity check
//
BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CComplexContentRestriction( ULONG ulWeight, PDeSerStream & stm );
//
// Member variable access
//
void SetExpression( WCHAR * pwcsExpression );
inline WCHAR * GetExpression();
LCID GetLocale() const { return _lcid; }
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
WCHAR * _pwcsExpression;
LCID _lcid;
};
//+-------------------------------------------------------------------------
//
// Class: CNatLanguageRestriction
//
// Purpose: Supports natural language queries
//
// History: 18-Jan-95 SitaramR Created
//
//--------------------------------------------------------------------------
class CNatLanguageRestriction : public CRestriction
{
public:
//
// Constructors
//
CNatLanguageRestriction( WCHAR const * pwcsPhrase,
CFullPropSpec const & Property,
LCID lcid = GetSystemDefaultLCID() );
//
// Copy constructors/assignment/clone
//
CNatLanguageRestriction * Clone();
//
// Destructors
//
~CNatLanguageRestriction();
//
// Validity check
//
inline BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CNatLanguageRestriction( ULONG ulWeight, PDeSerStream & stm );
//
// Member variable access
//
void SetPhrase( WCHAR const * pwcsPhrase );
inline WCHAR const * GetPhrase() const;
inline void SetProperty( CFullPropSpec const & Property );
inline CFullPropSpec const & GetProperty() const;
LCID GetLocale() const { return _lcid; }
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
CFullPropSpec _Property; // Property Name
WCHAR * _pwcsPhrase; // content
LCID _lcid;
};
//+-------------------------------------------------------------------------
//
// Class: CPropertyRestriction
//
// Purpose: Property <relop> constant restriction
//
// History: 08-Jan-93 KyleP Created
// 08-Nov-93 DwightKr Added new SetValue() methods
//
//--------------------------------------------------------------------------
class CPropertyRestriction : public CRestriction
{
public:
//
// Constructors
//
CPropertyRestriction();
CPropertyRestriction( ULONG relop,
CFullPropSpec const & Property,
CStorageVariant const & prval );
//
// Copy constructors/assignment/clone
//
CPropertyRestriction * Clone();
//
// Destructors
//
~CPropertyRestriction();
//
// Validity check
//
inline BOOL IsValid() const;
//
// Serialization
//
void Marshall( PSerStream & stm ) const;
CPropertyRestriction( ULONG ulWeight, PDeSerStream & stm );
//
// Member variable access
//
inline void SetRelation( ULONG relop );
inline ULONG Relation();
inline void SetProperty( CFullPropSpec const & Property );
inline CFullPropSpec const & GetProperty() const;
inline void SetValue( double dValue );
inline void SetUI4( ULONG ulValue );
inline void SetValue( ULONG ulValue );
inline void SetValue( LONG lValue );
inline void SetValue( LARGE_INTEGER llValue );
inline void SetValue( FILETIME ftValue );
inline void SetValue( CY CyValue );
inline void SetValue( float fValue );
inline void SetValue( SHORT sValue );
inline void SetValue( const CStorageVariant &prval );
inline void SetDate ( DATE dValue );
inline void SetBOOL( BOOL fValue );
void SetValue( BLOB & bValue );
void SetValue( WCHAR * pwcsValue );
void SetValue( GUID * pguidValue);
inline CStorageVariant const & Value();
# ifdef KDEXTMODE
void OfsKdDump(void *krnlSelf);
# endif
private:
void _CleanValue();
ULONG _relop; // Relation
CFullPropSpec _Property; // Property Name
CStorageVariant _prval; // Constant value
};
//
// Inline methods for CFullPropSpec
//
inline void * CFullPropSpec::operator new( size_t size )
{
void * p = CoTaskMemAlloc( size );
return( p );
}
inline void * CFullPropSpec::operator new( size_t size, void * p )
{
return( p );
}
inline void CFullPropSpec::operator delete( void * p )
{
if ( p )
CoTaskMemFree( p );
}
inline BOOL CFullPropSpec::IsValid() const
{
return ( _psProperty.ulKind == PRSPEC_PROPID ||
0 != _psProperty.lpwstr );
}
inline void CFullPropSpec::SetPropSet( GUID const & guidPropSet )
{
_guidPropSet = guidPropSet;
}
inline GUID const & CFullPropSpec::GetPropSet() const
{
return( _guidPropSet );
}
inline PROPSPEC CFullPropSpec::GetPropSpec() const
{
return( _psProperty );
}
inline WCHAR const * CFullPropSpec::GetPropertyName() const
{
return( _psProperty.lpwstr );
}
inline PROPID CFullPropSpec::GetPropertyPropid() const
{
return( _psProperty.propid );
}
inline BOOL CFullPropSpec::IsPropertyName() const
{
return( _psProperty.ulKind == PRSPEC_LPWSTR );
}
inline BOOL CFullPropSpec::IsPropertyPropid() const
{
return( _psProperty.ulKind == PRSPEC_PROPID );
}
inline BOOL CColumns::IsValid() const
{
return ( 0 != _aCol );
}
inline CFullPropSpec const & CColumns::Get( unsigned pos ) const
{
if ( pos < _cCol )
return( _aCol[pos] );
else
return( *(CFullPropSpec *)0 );
}
//
// Inline methods for CColumns
//
inline void * CColumns::operator new( size_t size )
{
void * p = CoTaskMemAlloc( size );
return( p );
}
inline void CColumns::operator delete( void * p )
{
if ( p )
CoTaskMemFree( p );
}
inline unsigned CColumns::Count() const
{
return( _cCol );
}
inline COLUMNSET * CColumns::CastToStruct()
{
return( (COLUMNSET *)this );
}
//
// Inline methods for CSortKey
//
inline CSortKey::CSortKey()
{
}
inline CSortKey::CSortKey( CFullPropSpec const & ps, ULONG dwOrder )
: _property( ps ),
_dwOrder( dwOrder )
{
}
inline CSortKey::CSortKey( CFullPropSpec const & ps, ULONG dwOrder, LCID locale )
: _property( ps ),
_dwOrder( dwOrder ),
_locale ( locale )
{
}
inline void * CSortKey::operator new( size_t size )
{
void * p = CoTaskMemAlloc( size );
return( p );
}
inline void CSortKey::operator delete( void * p )
{
if ( p )
CoTaskMemFree( p );
}
inline BOOL CSortKey::IsValid() const
{
return _property.IsValid();
}
inline void CSortKey::SetProperty( CFullPropSpec const & ps )
{
_property = ps;
}
inline void CSortKey::SetLocale( LCID locale )
{
_locale = locale;
}
inline CFullPropSpec const & CSortKey::GetProperty() const
{
return( _property );
}
inline LCID CSortKey::GetLocale() const
{
return( _locale );
}
inline ULONG CSortKey::GetOrder() const
{
return( _dwOrder );
}
//
// Inline methods of CSort
//
inline void * CSort::operator new( size_t size )
{
void * p = CoTaskMemAlloc( size );
return( p );
}
inline void CSort::operator delete( void * p )
{
if ( p )
CoTaskMemFree( p );
}
inline BOOL CSort::IsValid() const
{
return ( 0 != _ask );
}
inline SORTSET * CSort::CastToStruct()
{
return( (SORTSET *)this );
}
inline CSortKey const & CSort::Get( unsigned pos ) const
{
if ( pos < _csk )
{
return( _ask[pos] );
}
else
{
return( *(CSortKey *)0 );
}
}
inline unsigned
CSort::Count() const
{
return( _csk );
}
//
// Inline methods of CRestriction
//
inline CRestriction::CRestriction()
: _ulType( RTNone ),
_ulWeight( ulMaxRank )
{
}
inline CRestriction::CRestriction( ULONG RestrictionType, ULONG ulWeight )
: _ulType( RestrictionType ),
_ulWeight( ulWeight )
{
}
inline void * CRestriction::operator new( size_t size )
{
void * p = CoTaskMemAlloc( size );
return( p );
}
inline void CRestriction::operator delete( void * p )
{
if ( p )
CoTaskMemFree( p );
}
inline RESTRICTION * CRestriction::CastToStruct() const
{
//
// It would be nice to assert valid _ulType here, but there is
// no published assert mechanism for external use.
//
return ( (RESTRICTION *)this );
}
inline FULLPROPSPEC * CFullPropSpec::CastToStruct()
{
return((FULLPROPSPEC *) this);
}
inline FULLPROPSPEC const * CFullPropSpec::CastToStruct() const
{
return((FULLPROPSPEC const *) this);
}
inline ULONG CRestriction::Type() const
{
return ( _ulType );
}
inline ULONG CRestriction::Weight() const
{
return ( _ulWeight );
}
inline void CRestriction::SetWeight( ULONG ulWeight )
{
_ulWeight = ulWeight;
}
inline void CRestriction::SetType( ULONG RestrictionType )
{
_ulType = RestrictionType;
}
//
// Inline methods of CNodeRestriction
//
inline BOOL CNodeRestriction::AddChild( CRestriction * prst )
{
unsigned pos;
return( AddChild( prst, pos ) );
}
inline unsigned CNodeRestriction::Count() const
{
return( _cNode );
}
inline CNodeRestriction * CRestriction::CastToNode() const
{
//
// It would be nice to assert node type here, but there is
// no published assert mechanism for external use.
//
return ( (CNodeRestriction *)this );
}
inline void CNodeRestriction::SetChild( CRestriction * presChild,
unsigned pos )
{
if ( pos < _cNode )
_paNode[pos] = presChild;
}
inline CRestriction * CNodeRestriction::GetChild( unsigned pos ) const
{
if ( pos < _cNode )
return( _paNode[pos] );
else
return( 0 );
}
//
// Inline methods of CNotRestriction
//
inline CNotRestriction::CNotRestriction()
: CRestriction( RTNot, ulMaxRank ),
_pres(0)
{
}
inline CNotRestriction::CNotRestriction( CRestriction * pres )
: CRestriction( RTNot, ulMaxRank ),
_pres( pres )
{
}
inline BOOL CNotRestriction::IsValid() const
{
return ( 0 != _pres && _pres->IsValid() );
}
inline void CNotRestriction::SetChild( CRestriction * pres )
{
delete _pres;
_pres = pres;
}
inline CRestriction * CNotRestriction::GetChild()
{
return( _pres );
}
inline CRestriction * CNotRestriction::RemoveChild()
{
CRestriction *pRst = _pres;
_pres = 0;
return pRst;
}
//
// Inline methods of CVectorRestriction
//
inline CVectorRestriction::CVectorRestriction( ULONG ulRankMethod,
unsigned cInitAllocated )
: CNodeRestriction( RTVector, cInitAllocated )
{
SetRankMethod( ulRankMethod );
}
inline CVectorRestriction::CVectorRestriction( CVectorRestriction& vecRst )
: CNodeRestriction( vecRst ),
_ulRankMethod( vecRst.RankMethod() )
{
}
inline void CVectorRestriction::SetRankMethod( ULONG ulRankMethod )
{
if ( ulRankMethod >= VECTOR_RANK_MIN &&
ulRankMethod <= VECTOR_RANK_JACCARD )
{
_ulRankMethod = ulRankMethod;
}
else
{
_ulRankMethod = VECTOR_RANK_JACCARD;
}
}
inline ULONG CVectorRestriction::RankMethod() const
{
return ( _ulRankMethod );
}
//
// Inline methods of CContentRestriction
//
inline BOOL CContentRestriction::IsValid() const
{
return ( _Property.IsValid() && 0 != _pwcsPhrase );
}
inline WCHAR const * CContentRestriction::GetPhrase() const
{
return( _pwcsPhrase );
}
inline void CContentRestriction::SetProperty( CFullPropSpec const & Property )
{
_Property = Property;
}
inline CFullPropSpec const & CContentRestriction::GetProperty() const
{
return( _Property );
}
inline void CContentRestriction::SetFuzzyLevel( ULONG ulFuzzy )
{
_ulFuzzyLevel = ulFuzzy;
}
inline ULONG CContentRestriction::FuzzyLevel()
{
return( _ulFuzzyLevel );
}
//
// Inline methods of CComplexContentRestriction
//
inline BOOL CComplexContentRestriction::IsValid() const
{
return ( 0 != _pwcsExpression );
}
inline WCHAR * CComplexContentRestriction::GetExpression()
{
return( _pwcsExpression );
}
//
// Inline methods of CNatLanguageRestriction
//
inline BOOL CNatLanguageRestriction::IsValid() const
{
return ( _Property.IsValid() && 0 != _pwcsPhrase );
}
inline WCHAR const * CNatLanguageRestriction::GetPhrase() const
{
return( _pwcsPhrase );
}
inline void CNatLanguageRestriction::SetProperty( CFullPropSpec const & Property )
{
_Property = Property;
}
inline CFullPropSpec const & CNatLanguageRestriction::GetProperty() const
{
return( _Property );
}
//
// Inline methods of CPropertyRestriction
//
inline BOOL CPropertyRestriction::IsValid() const
{
return ( _Property.IsValid() && _prval.IsValid() );
}
inline void CPropertyRestriction::SetRelation( ULONG relop )
{
_relop = relop;
}
inline ULONG CPropertyRestriction::Relation()
{
return( _relop );
}
inline void CPropertyRestriction::SetProperty( CFullPropSpec const & Property )
{
_Property = Property;
}
inline CFullPropSpec const & CPropertyRestriction::GetProperty() const
{
return( _Property );
}
inline void CPropertyRestriction::SetValue( double dValue )
{
_prval = dValue;
}
inline void CPropertyRestriction::SetValue( ULONG ulValue )
{
_prval.SetUI4( ulValue );
}
inline void CPropertyRestriction::SetUI4( ULONG ulValue )
{
_prval.SetUI4( ulValue );
}
inline void CPropertyRestriction::SetValue( LONG lValue )
{
_prval = lValue;
}
inline void CPropertyRestriction::SetValue( LARGE_INTEGER llValue )
{
_prval = llValue;
}
inline void CPropertyRestriction::SetValue( FILETIME ftValue )
{
_prval = ftValue;
}
inline void CPropertyRestriction::SetValue( CY cyValue )
{
_prval = cyValue;
}
inline void CPropertyRestriction::SetValue( float fValue )
{
_prval = fValue;
}
inline void CPropertyRestriction::SetValue( SHORT sValue )
{
_prval = sValue;
}
inline void CPropertyRestriction::SetValue( const CStorageVariant &prval )
{
_prval = prval;
}
inline void CPropertyRestriction::SetBOOL( BOOL fValue )
{
_prval.SetBOOL( fValue );
}
inline void CPropertyRestriction::SetDate( DATE dValue )
{
_prval.SetDATE( dValue );
}
inline CStorageVariant const & CPropertyRestriction::Value()
{
return( _prval );
}
#endif // __RESTRICT_HXX__
Reference in New Issue Copy Permalink