mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
636 lines
17 KiB
636 lines
17 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996-1998.
|
|
//
|
|
// File: PropObj.hxx
|
|
//
|
|
// Contents: Encapsulates long-term access to single record of property
|
|
// store.
|
|
//
|
|
// Classes: CLockRecordForRead
|
|
//
|
|
// History: 27-Dec-19 KyleP Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include <proprec.hxx>
|
|
#include <prpstmgr.hxx>
|
|
#include <borrow.hxx>
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CLockRecordForRead
|
|
//
|
|
// Purpose: Smart encapsulation of read-lock
|
|
//
|
|
// History: 19-Dec-95 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CLockRecordForRead
|
|
{
|
|
public:
|
|
|
|
CLockRecordForRead( CPropertyStore & store, WORKID wid )
|
|
: _store( store ),
|
|
_record ( store.LockMgr().GetRecord( wid ) )
|
|
{
|
|
_store.AcquireRead( _record );
|
|
}
|
|
|
|
~CLockRecordForRead()
|
|
{
|
|
_store.ReleaseRead( _record );
|
|
}
|
|
|
|
private:
|
|
|
|
CReadWriteLockRecord & _record;
|
|
CPropertyStore & _store;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CLockRecordForWrite
|
|
//
|
|
// Purpose: Smart encapsulation of write-lock
|
|
//
|
|
// History: 19-Dec-95 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CLockRecordForWrite
|
|
{
|
|
public:
|
|
|
|
CLockRecordForWrite( CPropertyStore & store, WORKID wid )
|
|
: _store( store ),
|
|
_record ( store.LockMgr().GetRecord( wid ) )
|
|
{
|
|
_store.AcquireWrite( _record );
|
|
}
|
|
|
|
~CLockRecordForWrite()
|
|
{
|
|
_store.ReleaseWrite( _record );
|
|
}
|
|
|
|
private:
|
|
|
|
CReadWriteLockRecord & _record;
|
|
CPropertyStore & _store;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CLockAllRecordsForWrite
|
|
//
|
|
// Purpose: Smart encapsulation of total reader lock out.
|
|
//
|
|
// History: 18-Nov-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CLockAllRecordsForWrite
|
|
{
|
|
public:
|
|
|
|
CLockAllRecordsForWrite( CPropertyStore & store)
|
|
: _store( store )
|
|
{
|
|
_store.AcquireWriteOnAllRecords();
|
|
}
|
|
|
|
~CLockAllRecordsForWrite()
|
|
{
|
|
_store.ReleaseWriteOnAllRecords();
|
|
}
|
|
|
|
private:
|
|
|
|
CPropertyStore & _store;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CPropRecordNoLock
|
|
//
|
|
// Purpose: Encapsulates long-term access to single record of
|
|
// property store.
|
|
//
|
|
// History: 18-Mar-98 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CPropRecordNoLock
|
|
{
|
|
public:
|
|
|
|
inline CPropRecordNoLock( WORKID wid,
|
|
CPropertyStore & store,
|
|
BOOL fIntentToWrite );
|
|
|
|
inline void * operator new( size_t size, BYTE * pb );
|
|
|
|
inline void operator delete( void * p );
|
|
|
|
#if _MSC_VER >= 1200
|
|
inline void operator delete( void * p, BYTE * pb );
|
|
#endif
|
|
|
|
inline BOOL IsValid() { return 0 != _wid; }
|
|
|
|
protected:
|
|
|
|
friend class CPropertyStore;
|
|
|
|
// _wid should be the first to be declared. The constructor depends
|
|
// on that!
|
|
|
|
WORKID _wid;
|
|
COnDiskPropertyRecord * _prec;
|
|
CBorrowed _Borrowed;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPropRecordNoLock::CPropRecordNoLock, public
|
|
//
|
|
// Synopsis: Takes all locks required to hold record open until
|
|
// destruction.
|
|
//
|
|
// Arguments: [wid] -- Workid of record to open.
|
|
// [store] -- Property store.
|
|
//
|
|
// History: 18-Mar-98 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
inline CPropRecordNoLock::CPropRecordNoLock(
|
|
WORKID wid,
|
|
CPropertyStore & store,
|
|
BOOL fIntentToWrite )
|
|
: _wid ( (wid > store.MaxWorkId()) ? 0 : wid),
|
|
_Borrowed( store._xPhysStore.GetReference(),
|
|
_wid,
|
|
store._PropStoreInfo.RecordsPerPage(),
|
|
store._PropStoreInfo.RecordSize(),
|
|
fIntentToWrite )
|
|
{
|
|
//
|
|
// The next line can't be in ':' initialization because
|
|
// 1) _prec is first in structure to avoid C++ EH macro problems
|
|
// 2) If _prec is in ':' section it is initialized before _Borrowed!
|
|
//
|
|
|
|
_prec = _Borrowed.Get();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPropRecordNoLock::operator new, public
|
|
//
|
|
// Synopsis: Special operator new
|
|
//
|
|
// Arguments: [size] -- Size of allocation
|
|
// [pb] -- Pre-allocated memory
|
|
//
|
|
// History: 18-Mar-98 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void * CPropRecordNoLock::operator new( size_t size, BYTE * pb )
|
|
{
|
|
Win4Assert( 0 == ( ((ULONG_PTR)pb) & 0x3 ) );
|
|
|
|
if( 0 == pb )
|
|
THROW( CException( E_OUTOFMEMORY ) );
|
|
|
|
return pb;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPropRecordNoLock::operator delete, public
|
|
//
|
|
// Synopsis: Special operator delete
|
|
//
|
|
// Arguments: [p] -- Pointer to "delete"
|
|
//
|
|
// History: 03-Apr-96 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CPropRecordNoLock::operator delete( void * p )
|
|
{
|
|
}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void CPropRecordNoLock::operator delete(void * p, BYTE * pb) {}
|
|
#endif
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CPropRecord
|
|
//
|
|
// Purpose: Encapsulates long-term read access to single record of
|
|
// property store.
|
|
//
|
|
// History: 27-Dec-95 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CPropRecord : public CPropRecordNoLock
|
|
{
|
|
public:
|
|
|
|
inline CPropRecord( WORKID wid, CPropertyStore & store );
|
|
|
|
private:
|
|
|
|
friend class CPropertyStore;
|
|
|
|
// _wid should be the first to be declared. The constructor depends
|
|
// on that!
|
|
|
|
CLockRecordForRead _lock;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPropRecord::CPropRecord, public
|
|
//
|
|
// Synopsis: Takes all locks required to hold record open until
|
|
// destruction. The phystr buffer is opened for write with
|
|
// intent to read.
|
|
//
|
|
// Arguments: [wid] -- Workid of record to open.
|
|
// [store] -- Property store.
|
|
//
|
|
// History: 03-Apr-96 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
inline CPropRecord::CPropRecord( WORKID wid, CPropertyStore & store )
|
|
: CPropRecordNoLock(wid, store, FALSE),
|
|
_lock( store, _wid )
|
|
{
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CPrimaryPropRecord
|
|
//
|
|
// Purpose: Encapsulates long-term access to a top-level record
|
|
// of property store.
|
|
//
|
|
// History: 2-Jan-99 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
class CPrimaryPropRecord
|
|
{
|
|
public:
|
|
CPrimaryPropRecord( WORKID wid, CPropStoreManager & store )
|
|
: _PrimaryRecord( wid, store.GetPrimaryStore()) {}
|
|
|
|
void * operator new( size_t size, BYTE * pb )
|
|
{
|
|
Win4Assert( 0 == ( ((ULONG_PTR)pb) & 0x7 ) );
|
|
|
|
if( 0 == pb )
|
|
THROW( CException( E_OUTOFMEMORY ) );
|
|
|
|
return pb;
|
|
}
|
|
|
|
void operator delete( void * p ) {}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void operator delete( void * p, BYTE * pb ) {}
|
|
#endif
|
|
|
|
CPropRecord & GetPrimaryPropRecord() { return _PrimaryRecord; }
|
|
|
|
private:
|
|
|
|
CPropRecord _PrimaryRecord;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CCompositePropRecord
|
|
//
|
|
// Purpose: Encapsulates long-term access to the two top-level records
|
|
// of property store.
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
class CCompositePropRecord
|
|
{
|
|
public:
|
|
inline CCompositePropRecord( WORKID wid, CPropStoreManager & store );
|
|
inline void * operator new( size_t size, BYTE * pb );
|
|
|
|
inline void operator delete( void * p );
|
|
|
|
#if _MSC_VER >= 1200
|
|
inline void operator delete( void * p, BYTE * pb );
|
|
#endif
|
|
|
|
CPropRecord& GetPrimaryPropRecord() { return _PrimaryRecord; }
|
|
CPropRecord& GetSecondaryPropRecord() { return _SecondaryRecord; }
|
|
|
|
private:
|
|
|
|
//
|
|
// IMPORTANT: Don't change the order of these declarations. _PrimaryRecord
|
|
// should precede _SecondaryRecord.
|
|
// The order is used in the construction of this class.
|
|
//
|
|
CPropRecord _PrimaryRecord;
|
|
CPropRecord _SecondaryRecord;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCompositePropRecord::CCompositePropRecord, public
|
|
//
|
|
// Synopsis: Takes all locks required to hold the two top-level records
|
|
// open until destruction.
|
|
//
|
|
// Arguments: [wid] -- Workid of record to open.
|
|
// [store] -- Property store manager.
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
//
|
|
// IMPORTANT ASSUMPTION: _PrimaryRecord is constructed before _SecondaryRecord.
|
|
//
|
|
|
|
inline CCompositePropRecord::CCompositePropRecord( WORKID wid,
|
|
CPropStoreManager & store )
|
|
: _PrimaryRecord( wid, store.GetPrimaryStore()),
|
|
_SecondaryRecord(store.GetSecondaryTopLevelWid(wid, _PrimaryRecord),
|
|
store.GetSecondaryStore())
|
|
{
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCompositePropRecord::operator new, public
|
|
//
|
|
// Synopsis: Special operator new
|
|
//
|
|
// Arguments: [size] -- Size of allocation
|
|
// [pb] -- Pre-allocated memory
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void * CCompositePropRecord::operator new( size_t size, BYTE * pb )
|
|
{
|
|
Win4Assert( 0 == ( ((ULONG_PTR)pb) & 0x7 ) );
|
|
|
|
if( 0 == pb )
|
|
THROW( CException( E_OUTOFMEMORY ) );
|
|
|
|
return pb;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCompositePropRecord::operator delete, public
|
|
//
|
|
// Synopsis: Special operator delete
|
|
//
|
|
// Arguments: [p] -- Pointer to "delete"
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCompositePropRecord::operator delete( void * p )
|
|
{
|
|
}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void CCompositePropRecord::operator delete( void * p, BYTE * pb ) {}
|
|
#endif
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CPropRecordForWrites
|
|
//
|
|
// Purpose: Encapsulates long-term write access to single record of
|
|
// property store.
|
|
//
|
|
// History: 17-Mar-98 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CPropRecordForWrites : public CPropRecordNoLock
|
|
{
|
|
public:
|
|
|
|
inline CPropRecordForWrites( WORKID wid, CPropertyStore & store );
|
|
|
|
private:
|
|
|
|
friend class CPropertyStore;
|
|
|
|
CWriteAccess _writeLock;
|
|
CLockRecordForWrite _lock;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPropRecordForWrites::CPropRecordForWrites, public
|
|
//
|
|
// Synopsis: Takes all locks required to hold record open for write until
|
|
// destruction.
|
|
//
|
|
// Arguments: [wid] -- Workid of record to open.
|
|
// [store] -- Property store.
|
|
//
|
|
// History: 17-Mar-98 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
inline CPropRecordForWrites::CPropRecordForWrites( WORKID wid, CPropertyStore & store )
|
|
: CPropRecordNoLock(wid, store, TRUE),
|
|
_writeLock( store._rwAccess ),
|
|
_lock( store, _wid )
|
|
{
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CPrimaryPropRecordForWrites
|
|
//
|
|
// Purpose: Encapsulates long-term access to a top-level record
|
|
// of property store.
|
|
//
|
|
// History: 2-Jan-99 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
class CPrimaryPropRecordForWrites
|
|
{
|
|
public:
|
|
CPrimaryPropRecordForWrites( WORKID wid,
|
|
CPropStoreManager & store,
|
|
CMutexSem & mutex )
|
|
: _lock( mutex ),
|
|
_PrimaryRecord( wid, store.GetPrimaryStore())
|
|
{
|
|
}
|
|
|
|
void * operator new( size_t size, BYTE * pb )
|
|
{
|
|
Win4Assert( 0 == ( ((ULONG_PTR)pb) & 0x7 ) );
|
|
|
|
if( 0 == pb )
|
|
THROW( CException( E_OUTOFMEMORY ) );
|
|
|
|
return pb;
|
|
}
|
|
|
|
void operator delete( void * p ) {}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void operator delete( void * p, BYTE * pb ) {}
|
|
#endif
|
|
|
|
CPropRecordForWrites & GetPrimaryPropRecord() { return _PrimaryRecord; }
|
|
|
|
private:
|
|
|
|
CLock _lock;
|
|
CPropRecordForWrites _PrimaryRecord;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CCompositePropRecordForWrites
|
|
//
|
|
// Purpose: Encapsulates long-term access to the two top-level records
|
|
// of property store.
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
class CCompositePropRecordForWrites
|
|
{
|
|
public:
|
|
inline CCompositePropRecordForWrites( WORKID wid,
|
|
CPropStoreManager & store,
|
|
CMutexSem & mutex );
|
|
inline void * operator new( size_t size, BYTE * pb );
|
|
|
|
inline void operator delete( void * p );
|
|
|
|
#if _MSC_VER >= 1200
|
|
inline void operator delete( void * p, BYTE * pb );
|
|
#endif
|
|
|
|
inline CPropRecordForWrites& GetPrimaryPropRecord() { return _PrimaryRecord; }
|
|
inline CPropRecordForWrites& GetSecondaryPropRecord() { return _SecondaryRecord; }
|
|
|
|
private:
|
|
|
|
//
|
|
// IMPORTANT: Don't change the order of these declarations. _PrimaryRecord
|
|
// should precede _SecondaryRecord.
|
|
// The order is used in the construction of this class.
|
|
//
|
|
CLock _lock;
|
|
CPropRecordForWrites _PrimaryRecord;
|
|
CPropRecordForWrites _SecondaryRecord;
|
|
};
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCompositePropRecordForWrites::CCompositePropRecordForWrites, public
|
|
//
|
|
// Synopsis: Takes all locks required to hold the two top-level records
|
|
// open until destruction.
|
|
//
|
|
// Arguments: [wid] -- Workid of record to open.
|
|
// [store] -- Property store manager.
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
//
|
|
// IMPORTANT ASSUMPTION: _PrimaryRecord is constructed before _SecondaryRecord.
|
|
//
|
|
|
|
inline CCompositePropRecordForWrites::CCompositePropRecordForWrites(
|
|
WORKID wid,
|
|
CPropStoreManager & store,
|
|
CMutexSem & mutex )
|
|
: _lock( mutex ),
|
|
_PrimaryRecord( wid, store.GetPrimaryStore()),
|
|
_SecondaryRecord(store.GetSecondaryTopLevelWid(wid, _PrimaryRecord),
|
|
store.GetSecondaryStore())
|
|
{
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCompositePropRecordForWrites::operator new, public
|
|
//
|
|
// Synopsis: Special operator new
|
|
//
|
|
// Arguments: [size] -- Size of allocation
|
|
// [pb] -- Pre-allocated memory
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void * CCompositePropRecordForWrites::operator new( size_t size, BYTE * pb )
|
|
{
|
|
Win4Assert( 0 == ( ((ULONG_PTR)pb) & 0x7 ) );
|
|
|
|
if( 0 == pb )
|
|
THROW( CException( E_OUTOFMEMORY ) );
|
|
|
|
return pb;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCompositePropRecordForWrites::operator delete, public
|
|
//
|
|
// Synopsis: Special operator delete
|
|
//
|
|
// Arguments: [p] -- Pointer to "delete"
|
|
//
|
|
// History: 22-Oct-97 KrishnaN Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCompositePropRecordForWrites::operator delete( void * p )
|
|
{
|
|
}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void CCompositePropRecordForWrites::operator delete( void * p, BYTE * pb ) {}
|
|
#endif
|