//+------------------------------------------------------------------------- // // 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 #include // // 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 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__