//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: RCSTRMIT.HXX
//
// Contents: Persistent Recoverable Stream Iterators for fixed
// size records.
//
// Classes: CRcovStrmReadIter
// CRcovStrmWriteIter
// CRcovStrmAppendIter
//
// History: 25-Jan-94 SrikantS Created.
//
//----------------------------------------------------------------------------
#pragma once
#include <rcstxact.hxx>
//+---------------------------------------------------------------------------
//
// Class: CRcovStrmIter
//
// Purpose: Iterator for the recoverable stream class assuming fixed
// size records are stored in the stream.
//
// History: 1-25-94 srikants Created
//
//----------------------------------------------------------------------------
class CRcovStrmIter
{
public:
inline CRcovStrmIter( CRcovStrmTrans & trans , USHORT cbRec );
inline BOOL GetRec( void *pvRec, ULONG iRec );
inline void GetRec( void *pvRec );
inline ULONG GetVariableRecSize();
inline void GetVariableRecData( void * pvRec, ULONG cbRec );
BOOL AtEnd() const { return _trans.AtEnd(); }
inline void Advance();
inline void Seek( ULONG iRec );
ULONG UserDataSize( ULONG cRec ) { return cRec * (_cbRec + _CHECKSUM_SIZE); }
ULONG UserRecordCount( ULONG cbUserData ) { return cbUserData / (_cbRec + _CHECKSUM_SIZE); }
static unsigned SizeofChecksum() { return _CHECKSUM_SIZE; }
protected:
enum { _CHECKSUM_SIZE = sizeof(ULONG) };
inline ULONG CheckSum( void const * pvRec ) const;
inline ULONG CheckSum( void const * pvRec, unsigned cbRec ) const;
CRcovStrmTrans & _trans; // Transaction context
const USHORT _cbRec; // Size of user record, sans checksum
};
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmIter::CRcovStrmIter, public
//
// Synopsis: Constructor. Just squirrels away member variables.
//
// Arguments: [trans] -- Transaction context to iterate
// [cbRec] -- Size of 'records' to be written.
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline CRcovStrmIter::CRcovStrmIter( CRcovStrmTrans & trans , USHORT cbRec )
: _trans( trans ),
_cbRec(cbRec)
{
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmIter::Advance, public
//
// Synopsis: Moves to next record
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline void CRcovStrmIter::Advance()
{
Win4Assert( !AtEnd() );
_trans.Advance( _cbRec + _CHECKSUM_SIZE );
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmIter::Seek, public
//
// Synopsis: Moves to specified record
//
// Arguments: [iRec] -- Record to position to.
//
// History: 27-May-1998 KyleP Created
//
//----------------------------------------------------------------------------
inline void CRcovStrmIter::Seek( ULONG iRec )
{
_trans.Seek( iRec * (_cbRec + _CHECKSUM_SIZE) );
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmIter::CheckSum, protected
//
// Synopsis: Computes checksum for record
//
// Arguments: [pvRec] -- Record to examine
//
// Returns: Checksum
//
// History: 27-May-1998 KyleP Created
//
// Notes: Checksum is never 0. This is to avoid a common failed write
// scenario where zeros are written (or nothing is ever written)
// to a persistent data structure.
//
//----------------------------------------------------------------------------
inline ULONG CRcovStrmIter::CheckSum( void const * pvRec ) const
{
return CheckSum( pvRec, _cbRec );
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmIter::CheckSum, protected
//
// Synopsis: Computes checksum for variable size records
//
// Arguments: [pvRec] -- Record to examine
// [cbRec] -- Size of record
//
// Returns: Checksum
//
// History: 1-Jun-1998 VikasMan Created
//
// Notes: Checksum is never 0. This is to avoid a common failed write
// scenario where zeros are written (or nothing is ever written)
// to a persistent data structure.
//
//----------------------------------------------------------------------------
inline ULONG CRcovStrmIter::CheckSum( void const * pvRec, unsigned cbRec ) const
{
BYTE * pb = (BYTE *)pvRec;
ULONG ulCheckSum = 0;
//
// First, the DWORD granular portion
//
unsigned cbEnd = cbRec - _CHECKSUM_SIZE;
for ( unsigned i = 0; i <= cbEnd; i += _CHECKSUM_SIZE )
{
ulCheckSum += *(ULONG UNALIGNED *)pb;
pb += _CHECKSUM_SIZE;
}
//
// Then whatever is left.
//
ULONG ul = 0;
for ( ; i < cbRec; i++ )
{
ul = (ul << 8) + *pb;
pb++;
}
ulCheckSum += ul;
//
// Make sure the checksum is never zero. Just to avoid an obvious case
// of error where a whole section has been zero-ed (including checksum).
//
if ( 0 == ulCheckSum )
ulCheckSum = 1;
return ulCheckSum;
}
//+---------------------------------------------------------------------------
//
// Function: CRcovStrmIter::GetRec, public
//
// Synopsis: Gets the specified record.
//
// Effects: Positions the current pointer after the current read.
//
// Arguments: [pvRec] -- Buffer to read the contents into.
// [iRec] -- Number of the record, starting at 0.
//
// Returns: TRUE if a record was successfully read. FALSE if iRec
// is beyond the end of stream.
//
// History: 2-10-94 srikants Created
//
//----------------------------------------------------------------------------
inline BOOL CRcovStrmIter::GetRec( void * pvRec , ULONG iRec )
{
if ( !_trans.Seek(iRec * (_cbRec + _CHECKSUM_SIZE) ) || AtEnd() ) {
return FALSE;
}
ULONG cbRead = _trans.Read( pvRec, _cbRec );
Win4Assert( cbRead == _cbRec );
ULONG ulCheckSum;
if ( _CHECKSUM_SIZE != _trans.Read( &ulCheckSum, sizeof(ulCheckSum) ) )
{
ciDebugOut(( DEB_ERROR, "Error reading checksum for record %u (cbRec = %u).\n",
iRec, _cbRec ));
Win4Assert( !"Bad checksum" );
THROW( CException(CI_CORRUPT_CATALOG) );
}
if ( ulCheckSum != CheckSum( pvRec ) )
{
ciDebugOut(( DEB_ERROR,
"Incorrect checksum 0x%x (should be 0x%x) for record %u (cbRec = %u). pvRec = 0x%x\n",
CheckSum( pvRec ), ulCheckSum, iRec, _cbRec, pvRec ));
Win4Assert( !"Bad checksum" );
THROW( CException(CI_CORRUPT_CATALOG) );
}
return cbRead == _cbRec;
}
//+---------------------------------------------------------------------------
//
// Function: CRcovStrmIter::GetRec, public
//
// Synopsis: Gets the current record.
//
// Effects: Positions the current pointer after the current read.
//
// Arguments: [pvRec] -- Buffer to read the contents into.
//
// History: 27-May-1998 KyleP Created
//
//----------------------------------------------------------------------------
inline void CRcovStrmIter::GetRec( void *pvRec )
{
GetVariableRecData( pvRec, _cbRec );
}
//+---------------------------------------------------------------------------
//
// Function: CRcovStrmIter::GetVariableRecSize, public
//
// Synopsis: Gets the size of the current variable record.
//
// Effects: Positions the current pointer after the current read.
//
// Arguments:
//
// Returns: The size in bytes of the records
//
// History: 1-Jun-1998 VikasMan Created
//
//----------------------------------------------------------------------------
inline ULONG CRcovStrmIter::GetVariableRecSize()
{
Win4Assert( !AtEnd() );
ULONG cbRec;
ULONG cbRead;
// Read Size
cbRead = _trans.Read( &cbRec, sizeof( cbRec ) );
Win4Assert( sizeof( cbRec ) == cbRead );
Win4Assert( cbRec );
return cbRec;
}
//+---------------------------------------------------------------------------
//
// Function: CRcovStrmIter::GetVariableRecData, public
//
// Synopsis: Gets the current variable record.
//
// Effects: Positions the current pointer after the current read.
//
// Arguments: [pvRec] -- Pointer to buffer to read the contents into.
// [cbRec] -- Size in bytes of pvRec
//
//
// History: 1-Jun-1998 VikasMan Created
//
//----------------------------------------------------------------------------
inline void CRcovStrmIter::GetVariableRecData( void * pvRec, ULONG cbRec )
{
Win4Assert( !AtEnd() );
ULONG cbRead = _trans.Read( pvRec, cbRec );
Win4Assert( cbRead == cbRec );
ULONG ulCheckSum;
if ( _CHECKSUM_SIZE != _trans.Read( &ulCheckSum, sizeof(ulCheckSum) ) )
{
ciDebugOut(( DEB_ERROR, "Error reading checksum.\n" ));
Win4Assert( !"Bad checksum" );
THROW( CException(CI_CORRUPT_CATALOG) );
}
if ( ulCheckSum != CheckSum( pvRec, cbRec ) )
{
ciDebugOut(( DEB_ERROR,
"Incorrect checksum 0x%x (should be 0x%x). pvRec = 0x%x\n",
CheckSum( pvRec ), ulCheckSum, pvRec ));
Win4Assert( !"Bad checksum" );
THROW( CException(CI_CORRUPT_CATALOG) );
}
}
#if 0 // untested unsused new function
//+---------------------------------------------------------------------------
//
// Function: CRcovStrmIter::GetVariableRec, public
//
// Synopsis: Gets the current variable record. In the process would also
// allocate memory for it
//
// Effects: Positions the current pointer after the current read.
//
// Arguments: [ppvRec] -- Pointer to buffer to read the contents into.
//
// Returns: The size in bytes of *ppvRec
//
// History: 1-Jun-1998 VikasMan Created
//
//----------------------------------------------------------------------------
inline ULONG CRcovStrmIter::GetVariableRec( void ** ppvRec )
{
Win4Assert( !AtEnd() );
*ppvRec = NULL;
ULONG cbRec;
// Read Size
cbRec = GetVariableRecSize();
// Now allocate and read data
*ppvRec = (void*) new BYTE[cbRec];
XPtrST<BYTE> xRec((BYTE*)*ppvRec);
GetVariableRecData( *ppvRec, cbRec );
xRec.Acquire();
return cbRec;
}
#endif
//+---------------------------------------------------------------------------
//
// Class: CRcovStrmReadIter
//
// Purpose: Read-only version of recoverable stream iterator.
//
// History: 1-25-94 srikants Created
//
//----------------------------------------------------------------------------
class CRcovStrmReadIter : public CRcovStrmIter
{
public:
inline CRcovStrmReadIter( CRcovStrmReadTrans &readTrans, USHORT cbRec );
};
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmReadIter::CRcovStrmReadIter, public
//
// Synopsis: Constructor. Just squirrels away member variables.
//
// Arguments: [trans] -- Transaction context to iterate
// [cbRec] -- Size of 'records' to be written.
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline CRcovStrmReadIter::CRcovStrmReadIter( CRcovStrmReadTrans & readTrans , USHORT cbRec )
: CRcovStrmIter( readTrans, cbRec )
{
_trans.Seek(0);
}
//+---------------------------------------------------------------------------
//
// Class: CRcovStrmAppendIter
//
// Purpose: Iterator to append fixed size records to the recoverable
// streams. This is just an optimized case of a write iterator.
//
// History: 2-10-94 srikants Created
//
//----------------------------------------------------------------------------
class CRcovStrmAppendIter : public CRcovStrmIter
{
public:
inline CRcovStrmAppendIter( CRcovStrmAppendTrans &appendTrans, USHORT cbRec );
inline void AppendRec( const void *pvRec );
inline void AppendVariableRec( const void *pvRec, ULONG cbRec );
private:
CRcovStrmAppendTrans & _appendTrans;
};
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmAppendIter::CRcovStrmAppendIter, public
//
// Synopsis: Constructor. Just squirrels away member variables.
//
// Arguments: [trans] -- Transaction context to iterate
// [cbRec] -- Size of 'records' to be written.
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline CRcovStrmAppendIter::CRcovStrmAppendIter( CRcovStrmAppendTrans & trans, USHORT cbRec )
: CRcovStrmIter( trans, cbRec ),
_appendTrans( trans )
{
_appendTrans.Seek( ENDOFSTRM );
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmAppendIter::AppendRec, public
//
// Synopsis: Appends record to end of stream.
//
// Arguments: [pvRec] -- Record to append.
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline void CRcovStrmAppendIter::AppendRec( const void *pvRec )
{
_appendTrans.Append( pvRec, _cbRec );
ULONG ulCheckSum = CheckSum( pvRec );
_appendTrans.Append( &ulCheckSum, sizeof(ulCheckSum), FALSE );
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmAppendIter::AppendVariableRec, public
//
// Synopsis: Appends variable size record to end of stream
//
// Arguments: [pvRec] -- Record to append.
// [cbRec] -- Count in bytes of pvRec
//
// Returns: void
//
// History: 01-Jun-1998 VikasMan Created
//
//----------------------------------------------------------------------------
inline void CRcovStrmAppendIter::AppendVariableRec( const void *pvRec,
ULONG cbRec )
{
ULONG ulCheckSum;
Win4Assert( cbRec != 0 && pvRec != 0 );
// first write the size
_appendTrans.Append( &cbRec, sizeof( cbRec ), FALSE );
// next write the data
_appendTrans.Append( pvRec, cbRec );
ulCheckSum = CheckSum( pvRec, cbRec );
_appendTrans.Append( &ulCheckSum, sizeof(ulCheckSum), FALSE );
}
//+---------------------------------------------------------------------------
//
// Class: CRcovStrmWriteIter
//
// Purpose: Iterator for writing fixed size anywhere in the
// recoverable stream.
//
// History: 2-10-94 srikants Created
//
//----------------------------------------------------------------------------
class CRcovStrmWriteIter : public CRcovStrmIter
{
public:
inline CRcovStrmWriteIter( CRcovStrmWriteTrans & writeTrans, USHORT cbRec );
inline BOOL SetRec( const void *pvBuf, ULONG iRec );
inline void SetRec( const void *pvBuf );
inline void AppendRec( const void *pvBuf );
#if 0 // untested unused new function
inline void SetVariableRec( const void *pvRec,
ULONG cbRec,
BOOL fAppend = FALSE );
#endif
private:
CRcovStrmWriteTrans & _writeTrans;
};
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmWriteIter::CRcovStrmWriteIter, public
//
// Synopsis: Constructor. Just squirrels away member variables.
//
// Arguments: [trans] -- Transaction context to iterate
// [cbRec] -- Size of 'records' to be written.
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline CRcovStrmWriteIter::CRcovStrmWriteIter( CRcovStrmWriteTrans & writeTrans, USHORT cbRec )
: CRcovStrmIter( writeTrans, cbRec ),
_writeTrans(writeTrans)
{
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmWriteIter::SetRec, public
//
// Synopsis: Writes specified record to stream.
//
// Arguments: [pvRec] -- Record data
// [iRec] -- Location at which write should occur
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline BOOL CRcovStrmWriteIter::SetRec( const void * pvRec, ULONG iRec )
{
if (! _writeTrans.Seek( (_cbRec + _CHECKSUM_SIZE) * iRec ) || AtEnd() )
{
return FALSE;
}
SetRec( pvRec );
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmWriteIter::SetRec, public
//
// Synopsis: Writes specified record to current location in stream.
//
// Arguments: [pvRec] -- Record data
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline void CRcovStrmWriteIter::SetRec( const void * pvRec )
{
_writeTrans.Write( pvRec, _cbRec );
ULONG ulCheckSum = CheckSum( pvRec );
_writeTrans.Write( &ulCheckSum, sizeof(ulCheckSum) );
}
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmWriteIter::AppendRec, public
//
// Synopsis: Appends record to end of stream.
//
// Arguments: [pvRec] -- Record to append.
//
// History: 27-May-1998 KyleP Added header
//
//----------------------------------------------------------------------------
inline void CRcovStrmWriteIter::AppendRec( const void *pvRec )
{
_writeTrans.Append( pvRec, _cbRec );
ULONG ulCheckSum = CheckSum( pvRec );
_writeTrans.Write( &ulCheckSum, sizeof(ulCheckSum) );
}
#if 0 // untested unused new function
//+---------------------------------------------------------------------------
//
// Method: CRcovStrmWriteIter::SetVariableRec, public
//
// Synopsis: Writes/Appends variable size record to end of stream
//
// Arguments: [pvRec] -- Record to append.
// [cbRec] -- Count in bytes of pvRec
// [fAppend] -- If TRUE, then record is appended
//
// Returns: void
//
// History: 01-Jun-1998 VikasMan Created
//
//----------------------------------------------------------------------------
inline void CRcovStrmWriteIter::SetVariableRec( const void *pvRec,
ULONG cbRec,
BOOL fAppend /* = FALSE */ )
{
ULONG ulCheckSum;
Win4Assert( cbRec != 0 && pvRec != 0 );
// first write the size
if ( fAppend )
_writeTrans.Append( &cbRec, sizeof( cbRec ) );
else
_writeTrans.Write( &cbRec, sizeof( cbRec ) );
// next write the data
_writeTrans.Write( pvRec, cbRec );
ulCheckSum = CheckSum( pvRec, cbRec );
_writeTrans.Write( &ulCheckSum, sizeof(ulCheckSum) );
}
#endif