|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995
//
// File: PropRec.hxx
//
// Contents: Record format for persistent property store
//
// Classes: CPropertyRecord
//
// History: 28-Dec-19 KyleP Created
//
//----------------------------------------------------------------------------
#if !defined( __PROPREC_HXX__ )
#define __PROPREC_HXX__
class CStorageVariant;
//+-------------------------------------------------------------------------
//
// Class: COnDiskPropertyRecord
//
// Purpose: Manipulates property values for single object/record
//
// History: 28-Dec-95 KyleP Created
//
// Notes: This class is like a template, that applies structure to a
// single record of a memory-mapped file. Layout of data
// members corresponds exactly to the on-disk version of the
// property store.
//
// Layout of a record is as follows:
// 1) Per-record state.
// Count of additional records appended physically
// to this one. Low bit used to indicate record
// is in use.
// Used space in variable property area (in dwords)
// Link to overflow record.
// 2) Existence bitmap. One dword / 16 properties, rounded up
// to nearest dword. First bit (of two) indicates existence.
// Second indicates existence is on overflow.
// 3) Fixed length property storage.
// 4) Variable length property storage. For each property:
// Dword for size.
// High word is size (in dwords) used by current property.
// Low word is allocated size (in dwords).
// Allocated space.
//
//--------------------------------------------------------------------------
#pragma pack(4)
class COnDiskPropertyRecord{ enum ERecType { eVirgin = 0x0000, eTopLevel = 0xAAAA, eOverflow = 0x5555, eFree = 0xBBBB };
public:
inline void * operator new( size_t size, ULONG record, BYTE * pBase, ULONG culRec ); inline void operator delete( void * p );
inline static ULONG MinStreamSize( ULONG record, ULONG culRec );
//
// Block linking
//
inline WORKID OverflowBlock() const; inline void SetOverflowBlock( WORKID wid );
inline WORKID PreviousBlock() const; inline void SetPreviousBlock( WORKID wid );
//
// Simple reads / writes.
//
void ReadFixed( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG cTotal, ULONG Type, PROPVARIANT & var, BYTE * pbExtra, unsigned * pcbExtra );
BOOL ReadVariable( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG cTotal, ULONG cFixed, PROPVARIANT & var, BYTE * pbExtra, unsigned * pcbExtra );
void WriteFixed( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG Type, ULONG cTotal, CStorageVariant const & var );
BOOL WriteVariable( ULONG Ordinal, ULONG Mask, ULONG oStart, ULONG cTotal, ULONG cFixed, ULONG culRec, CStorageVariant const & var );
//
// Multi-record properties.
//
inline BOOL IsLongRecord(); inline ULONG CountRecords() const; inline void MakeLongRecord( ULONG cRecords );
inline BOOL IsValidType() const; inline BOOL IsValidInUseRecord( WORKID wid, ULONG cRecPerPage ) const; inline BOOL IsValidLength( WORKID wid, ULONG cRecPerPage ) const; inline BOOL AreLinksValid( WORKID widMax ) const;
static ULONG CountRecordsToStore( ULONG cTotal, ULONG culRec, CStorageVariant const & var );
//
// Free list management
//
inline void MakeFreeRecord( ULONG cRecords, WORKID widNextFree, ULONG cNextFree, ULONG culRec ); inline void MakeFreeRecord( WORKID widNextFree, ULONG cNextFree, ULONG culRec ); inline ULONG GetNextFreeRecord() const; inline ULONG GetPreviousFreeRecord() const; inline ULONG GetNextFreeSize() const; inline void SetNextFree( WORKID widNextFree, ULONG cNextFree ); inline void SetPreviousFreeRecord( WORKID widPreviousFree );
//
// Overflow records chaining.
//
inline ULONG GetOverflowChainLength() const; inline void IncrementOverflowChainLength(); inline void SetOverflowChainLength( ULONG cOvfl );
//
// Existence / Use
//
inline BOOL IsInUse() const; inline BOOL IsTopLevel() const; inline BOOL IsOverflow() const; inline BOOL IsFreeRecord() const;
inline void MakeNewTopLevel(); inline void MakeNewOverflow(); inline void ForceOverflow();
inline void Clear( ULONG culRec ); inline void ClearAll( ULONG culRec );
inline BOOL HasProperties( ULONG cTotal );
//
// Reader / Writer
//
inline BOOL IsBeingWritten(); inline BOOL IsBeingRead();
inline void AddReader(); inline void RemoveReader(); inline void AddWriter(); inline void RemoveWriter();
# if CIDBG == 1
inline BOOL LokIsBeingWrittenTwice(); inline BOOL IsEmpty( ULONG culRec );# endif
inline static ULONG FixedOverhead();
inline BOOL IsStored( ULONG Ordinal, ULONG mask ); inline BOOL IsStoredOnOverflow( ULONG Ordinal, ULONG mask );
private:
inline void SetStored( ULONG Ordinal, ULONG mask ); inline void ClearStored( ULONG Ordinal, ULONG mask );
inline void SetStoredOnOverflow( ULONG Ordinal, ULONG mask ); inline void ClearStoredOnOverflow( ULONG Ordinal, ULONG mask );
inline static ULONG UsedSize( ULONG ul ); inline static ULONG AllocatedSize( ULONG ul ) { return (ul & 0xFFFF); }
inline static void SetUsedSize( ULONG * pul, ULONG ul ); inline static void SetAllocatedSize( ULONG * pul, ULONG ul );
inline static void MarkOverflow( ULONG * pul ); inline static BOOL IsOverflow( ULONG ul );
inline ULONG FreeVariableSpace( ULONG cTotal, ULONG cFixed, ULONG oStart, ULONG cbRec );
inline ULONG * FindVariableProp( ULONG Ordinal, ULONG cFixed, ULONG cTotal, ULONG oStart );
static void RightCompress( ULONG * pul, ULONG cul, ULONG cRemaining );
static ULONG * LeftCompress( ULONG * pul, ULONG cul, ULONG * pulEnd );
USHORT _type; // Type of the record
USHORT _cAdditionalRecords; // For long records, size (in records) of long record.
DWORD _dwFlags; // Reserved for future use
ULONG _culVariableUsed; // Bytes of record that are in use. Variable section only.
WORKID _ulOverflow; // Pointer to overflow block.
WORKID _ulPrev; // Pointer to the previous record. For toplevel
// records, this will be the length of the
// chain.
ULONG _aul[1]; // Rest of block is variable:
// a) Existence bits
// b) Fixed size properties
// c) Variable size properties
};
#pragma pack()
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::operator new, public
//
// Synopsis: Special operator new (computes offset of record in file)
//
// Arguments: [size] -- Required (and unused) parameter
// [record] -- Record number
// [pBase] -- Address of record 0
// [culRec] -- Size in dwords of single record
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void * COnDiskPropertyRecord::operator new( size_t size, ULONG record, BYTE * pBase, ULONG culRec ){ ciDebugOut(( DEB_PROPSTORE, "PROPSTORE: Opening record at offset 0x%x (%d)\n", record * culRec * 4, record * culRec * 4 ));
return pBase + record * culRec * 4;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::operator delete, public
//
// Synopsis: Just to make sure it isn't called...
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::operator delete( void * p ){ // No action. This is mapped onto a file.
}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsLongRecord, public
//
// Returns: TRUE if record is long (consists of more than one
// physically contiguous record).
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsLongRecord(){ return (_cAdditionalRecords != 0);}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::CountRecords, public
//
// Returns: Size of record (in one-records)
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline ULONG COnDiskPropertyRecord::CountRecords() const{ return _cAdditionalRecords + 1;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MakeLongRecord, public
//
// Synopsis: Indicates record is long.
//
// Arguments: [cRecords] -- Number of physically contiguous records.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::MakeLongRecord( ULONG cRecords ){ Win4Assert( cRecords >= 1 );// Win4Assert( !HasProperties( 1 ) );
_cAdditionalRecords = (USHORT) (cRecords - 1);}
//+---------------------------------------------------------------------------
//
// Member: COnDiskProperyRecord::IsFreeRecord
//
// Synopsis: Tests if the current record is a Free record.
//
// History: 2-23-96 srikants Created
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsFreeRecord() const{ Win4Assert( 0 == _dwFlags ); // until we have some use for flags
return eFree == _type;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MakeFreeRecord
//
// Synopsis: Makes the current record a free record.
//
// Arguments: [ulNextFree] - The workid of the next free record
// [cFree] - Size of next free record
// [culRec] - Count of ULONGs per record.
//
// History: 4-11-96 srikants Created
//
// Notes: It is assumed that the "_cAdditionalRecords" is correctly set
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::MakeFreeRecord( WORKID ulNextFree, ULONG cFree, ULONG culRec ){ Clear( culRec );
SetNextFree( ulNextFree, cFree );}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MakeFreeRecord
//
// Synopsis: Makes the current record a free record of length "cRecords"
//
// Arguments: [cRecords] - Length of this block in "records"
// [ulNextFree] - The next free record wid
// [cFree] - Size of next free record
// [culRec] - Count of ULONGs per record
//
// History: 4-11-96 srikants Created
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::MakeFreeRecord( ULONG cRecords, WORKID ulNextFree, ULONG cFree, ULONG culRec ){ MakeLongRecord( cRecords ); MakeFreeRecord( ulNextFree, cFree, culRec );}
inline void COnDiskPropertyRecord::SetNextFree( WORKID widNextFree, ULONG cNextFree ){ _ulOverflow = widNextFree; _culVariableUsed = cNextFree;}
inline void COnDiskPropertyRecord::SetPreviousFreeRecord( WORKID widPrevFree ){ _ulPrev = widPrevFree;}
inline ULONG COnDiskPropertyRecord::GetNextFreeRecord() const{ Win4Assert( eFree == _type ); return _ulOverflow;}
inline ULONG COnDiskPropertyRecord::GetPreviousFreeRecord() const{ Win4Assert( eFree == _type ); return _ulPrev;}
inline ULONG COnDiskPropertyRecord::GetNextFreeSize() const{ Win4Assert( eFree == _type ); return _culVariableUsed;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MinStreamSize, public
//
// Synopsis: Computes position of record in stream
//
// Arguments: [record] -- Record number
// [culRec] -- Size in dwords of single record
//
// Returns: Minimum size stream that can hold this record.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline ULONG COnDiskPropertyRecord::MinStreamSize( ULONG record, ULONG culRec ){ return (record + 1) * culRec * 4;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::OverflowBlock, public
//
// Returns: Overflow block id (zero if no overflow block)
//
// History: 27-Dec-95 KyleP Created.
//
// Notes: For a free list record, this will be a link to the
// next free block in the list.
//
//----------------------------------------------------------------------------
inline WORKID COnDiskPropertyRecord::OverflowBlock() const{ return _ulOverflow;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::SetOverflowBlock, public
//
// Synopsis: Sets overflow block id (zero if no overflow block)
//
// Arguments: [wid] -- Workid (record number) of link
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::SetOverflowBlock( WORKID wid ){ _ulOverflow = wid;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::PreviousBlock
//
// Synopsis: Returns the previous block value.
//
// History: 4-10-96 srikants Created
//
// Notes: For a top-level record, this will be the length of the
// overflow chain records.
// For a free list record, this will be the size of the next
// free block in the list.
//
//----------------------------------------------------------------------------
inline WORKID COnDiskPropertyRecord::PreviousBlock() const{ return _ulPrev;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::SetPreviousBlock
//
// Synopsis: Updates the previous block value.
//
// Arguments: [widPrev] - Value of the previous block
//
// History: 4-10-96 srikants Created
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::SetPreviousBlock( WORKID widPrev ){ Win4Assert( eOverflow == _type ); _ulPrev = widPrev;}
inline ULONG COnDiskPropertyRecord::GetOverflowChainLength() const{ Win4Assert( eTopLevel == _type ); return _ulPrev;}
inline void COnDiskPropertyRecord::IncrementOverflowChainLength(){ Win4Assert( eTopLevel == _type ); _ulPrev++;}
inline void COnDiskPropertyRecord::SetOverflowChainLength( ULONG cCount ){ _ulPrev = cCount;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsInUse, public
//
// Returns: TRUE if record is in use.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsInUse() const{ return eTopLevel == _type || eOverflow == _type;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::HasProperties, public
//
// Arguments: [cTotal] -- Total number of properties in record.
//
// Returns: TRUE if record has properties stored on it. May be
// in use. Used for debugging.
//
// History: 22-Feb-96 KyleP Created.
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::HasProperties( ULONG cTotal ){ for ( ULONG cBitWords = ((cTotal-1) / 16) + 1; cBitWords > 0; cBitWords-- ) { if ( _aul[cBitWords-1] != 0 ) return TRUE; }
return FALSE;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MakeNewTopLevel
//
// Synopsis: Marks the current record as a top level record.
//
// History: 2-23-96 srikants Created
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::MakeNewTopLevel(){ _type = eTopLevel; _ulPrev = _ulOverflow = 0; // Setting the length of overflow chain
_culVariableUsed = 0;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskProperyRecord::IsTopLevel
//
// Synopsis: Tests if the current record is a TopLevel record.
//
// History: 2-23-96 srikants Created
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsTopLevel() const{ Win4Assert( 0 == _dwFlags ); // until we have some use for flags
return eTopLevel == _type;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MakeNewOverflow
//
// Synopsis: Marks the record as an overflow record
//
// History: 4-10-96 srikants Created
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::MakeNewOverflow(){ _type = eOverflow; _ulPrev = _ulOverflow = 0; _culVariableUsed = 0;}
inline void COnDiskPropertyRecord::ForceOverflow(){ _type = eOverflow;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsOverflow
//
// Synopsis: Tests if this is an overflow record.
//
// History: 4-10-96 srikants Created
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsOverflow() const{ Win4Assert( 0 == _dwFlags ); // until we have some use for flags
return eOverflow == _type;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsValidLength
//
// Synopsis: Tests if the length is valid for this record for the given
// WORKID and records per page. A record can never span page and
// so the WORKID will help us determine if the length is valid
// or not.
//
// Arguments: [wid] - WORKID of this record
// [cRecPerPage] - Number of records per page.
//
// History: 4-10-96 srikants Created
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsValidLength( WORKID wid, ULONG cRecPerPage ) const{ WORKID offset = wid % cRecPerPage; return offset+_cAdditionalRecords < cRecPerPage;}
inline BOOL COnDiskPropertyRecord::IsValidInUseRecord( WORKID wid, ULONG cRecPerPage ) const{ if ( eTopLevel == _type || eOverflow == _type ) { return IsValidLength( wid, cRecPerPage ); } else return FALSE;}
inline BOOL COnDiskPropertyRecord::IsValidType() const{ return eTopLevel == _type || eOverflow == _type || eFree == _type || eVirgin == _type;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::AreLinksValid
//
// Synopsis: Tests if the forward and backward links are valid given the
// widMax.
//
// Arguments: [widMax] - The maximum workid that is in use for the entire
// property store.
//
// History: 4-10-96 srikants Created
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::AreLinksValid( WORKID widMax ) const{ return _ulOverflow <= widMax && _ulPrev <= widMax;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::Clear, public
//
// Synopsis: Zero complete record.
//
// Arguments: [culRec] -- Size in dwords of record
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::Clear( ULONG culRec ){ Win4Assert( 2 == offsetof( COnDiskPropertyRecord, _cAdditionalRecords ) ); Win4Assert( 4 == offsetof( COnDiskPropertyRecord, _dwFlags ) );
RtlZeroMemory( &this->_dwFlags, culRec * CountRecords() * sizeof (ULONG) - offsetof( COnDiskPropertyRecord, _dwFlags ) );
_type = eFree;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::ClearAll
//
// Synopsis: Clears the entire record to be 0 filled.
//
// Arguments: [culRec] -
//
// History: 3-25-96 srikants Created
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::ClearAll( ULONG culRec ){ Clear( culRec );
_cAdditionalRecords = 0; _type = 0;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::FixedOverhead, public
//
// Returns: Size of class, sans uninterpreted variable area.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline ULONG COnDiskPropertyRecord::FixedOverhead(){ return ((ULONG) &((COnDiskPropertyRecord *)0)->_aul[0]) / 4;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsStored, public
//
// Synopsis: Test property existence.
//
// Arguments: [Ordinal] -- Position of property in list.
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
//
// Returns: TRUE if property at [Ordinal] is stored.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsStored( ULONG Ordinal, ULONG mask ){ return ( (_aul[Ordinal / 16] & mask) != 0 );}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::SetStored, public
//
// Synopsis: Marks property as stored.
//
// Arguments: [Ordinal] -- Position of property in list.
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::SetStored( ULONG Ordinal, ULONG mask ){ _aul[Ordinal / 16] |= mask;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::ClearStored, public
//
// Synopsis: Marks property as not stored.
//
// Arguments: [Ordinal] -- Position of property in list.
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::ClearStored( ULONG Ordinal, ULONG mask ){ _aul[Ordinal / 16] &= ~mask;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsStoredOnOverflow, public
//
// Synopsis: Test property overflow.
//
// Arguments: [Ordinal] -- Position of property in list.
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
//
// Returns: TRUE if property at [Ordinal] is stored on overflow record.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsStoredOnOverflow( ULONG Ordinal, ULONG mask ){ Win4Assert( ( mask & (mask - 1) ) == 0 ); return ( (_aul[Ordinal / 16] & (mask << 1)) != 0 );}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::SetStoredOnOverflow, public
//
// Synopsis: Marks property as stored on overflow record.
//
// Arguments: [Ordinal] -- Position of property in list.
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::SetStoredOnOverflow( ULONG Ordinal, ULONG mask ){ Win4Assert( ( mask & (mask - 1) ) == 0 ); _aul[Ordinal / 16] |= (mask << 1);}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::ClearStoredOnOverflow, public
//
// Synopsis: Marks property as not stored on overflow record.
//
// Arguments: [Ordinal] -- Position of property in list.
// [mask] -- Bitmask of ordinal. Pre-computed for efficiency.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::ClearStoredOnOverflow( ULONG Ordinal, ULONG mask ){ Win4Assert( ( mask & (mask - 1) ) == 0 ); _aul[Ordinal / 16] &= ~(mask << 1);}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::UsedSize, public
//
// Arguments: [ul] -- Dword containing used/alloced size fields.
//
// Returns: Used size.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline ULONG COnDiskPropertyRecord::UsedSize( ULONG ul ){ ULONG size = ul >> 16;
if ( size == 0xFFFF) size = 0;
return size;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::SetUsedSize, public
//
// Synopsis: Sets used size.
//
// Arguments: [pul] -- Pointer to dword containing used/alloced size fields.
// [ul] -- New used size
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::SetUsedSize( ULONG * pul, ULONG ul ){ Win4Assert( AllocatedSize(*pul) >= ul || ul == 0xFFFF ); *pul = (*pul & 0xFFFF) | (ul << 16);}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::SetAllocatedSize, public
//
// Synopsis: Sets allocated size.
//
// Arguments: [pul] -- Pointer to dword containing used/alloced size fields.
// [ul] -- New allocated size
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::SetAllocatedSize( ULONG * pul, ULONG ul ){ Win4Assert( (ul >> 16) == 0 ); *pul = (*pul & 0xFFFF0000) | ul;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::MarkOverflow, public
//
// Synopsis: Indicates variable stored in overflow record.
//
// Arguments: [pul] -- Pointer to dword containing used/alloced size fields.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline void COnDiskPropertyRecord::MarkOverflow( ULONG * pul ){ SetUsedSize( pul, 0xFFFF );}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::IsOverflow, public
//
// Arguments: [ul] -- dword containing used/alloced size fields.
//
// Returns: TRUE if variable is in overflow record.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline BOOL COnDiskPropertyRecord::IsOverflow( ULONG ul ){ return ((ul & 0xFFFF0000) == 0xFFFF0000);}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::FreeVariableSpace, public
//
// Synopsis: Compute free space.
//
// Arguments: [cTotal] -- Total number of properties in record.
// [cFixed] -- Count of fixed properties in record.
// [oStart] -- Offset to start of variable storage area
// [culRec] -- Size in dwords of record.
//
// Returns: Unused variable space in record.
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline ULONG COnDiskPropertyRecord::FreeVariableSpace( ULONG cTotal, ULONG cFixed, ULONG oStart, ULONG culRec ){ LONG lFree = (culRec * CountRecords()) - // Record size
FixedOverhead() - // Fixed overhead
((cTotal - 1) / 16 + 1) - // Existence bitmap
oStart - // Fixed property storage
(cTotal - cFixed) - // Used/Alloc sizes
_culVariableUsed; // Variable properties
Win4Assert(lFree >= 0);
return (ULONG) lFree;}
//+---------------------------------------------------------------------------
//
// Member: COnDiskPropertyRecord::FindVariableProp, public
//
// Synopsis: Locate start of property.
//
// Arguments: [Ordinal] -- Ordinal of property to locate.
// [cFixed] -- Count of fixed properties in record.
// [cTotal] -- Total number of properties in record.
// [oStart] -- Offset to start of variable storage area.
//
// Returns: Pointer to start of property
//
// History: 27-Dec-95 KyleP Created.
//
//----------------------------------------------------------------------------
inline ULONG * COnDiskPropertyRecord::FindVariableProp( ULONG Ordinal, ULONG cFixed, ULONG cTotal, ULONG oStart ){ ciDebugOut(( DEB_PROPSTORE, "Ordinal = %d, %d fixed, %d total, offset = 0x%x\n", Ordinal, cFixed, cTotal, oStart )); //
// Start is after existance bitmap and fixed properties.
//
ULONG * pulVarRecord = &_aul[ (cTotal-1) / 16 + 1 + oStart];#if CIDBG
ULONG culUsed = 0;#endif // CIDBG
//
// Skip over variable props. The "+1" is for the allocation dword.
//
for ( ULONG i = cFixed; i < Ordinal; i++ ) { ciDebugOut(( DEB_PROPSTORE, "Ordinal %d starts at offset 0x%x (%d)\n", i, (ULONG)pulVarRecord - (ULONG)this, (ULONG)pulVarRecord - (ULONG)this ));
#if CIDBG
culUsed += UsedSize(*pulVarRecord); #endif
pulVarRecord += AllocatedSize(*pulVarRecord) + 1; }
ciDebugOut(( DEB_PROPSTORE, "Ordinal %d starts at offset 0x%x (%d)\n", i, (ULONG)pulVarRecord - (ULONG)this, (ULONG)pulVarRecord - (ULONG)this ));
Win4Assert( culUsed + UsedSize(*pulVarRecord) <= _culVariableUsed ); return pulVarRecord;}
#if CIDBG == 1
inline BOOL COnDiskPropertyRecord::IsEmpty( ULONG culRec ){ BOOL fEmpty = ( 0 == _culVariableUsed && 0 == _ulOverflow && 0 == _ulPrev );
for ( ULONG i = 0; i < (culRec-5); i++ ) { if ( 0 != _aul[i] ) { fEmpty = FALSE; break; } }
return fEmpty;}
#endif // CIDBG
#endif // __PROPREC_HXX__
|
