windows-nt/Source/XPSP1/NT/com/ole32/stg/h/dl.hxx

388 lines
9.4 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1992.
//
// File: dl.hxx
//
// Contents: Delta list headers for streams
//
// Classes: SDeltaBlock
// CDeltaList
//
// History: 28-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
#ifndef __DL_HXX__
#define __DL_HXX__
#define DL_GET 0
#define DL_CREATE 1
#define DL_READ 2
class CTransactedStream;
SAFE_DFBASED_PTR(CBasedTransactedStreamPtr, CTransactedStream);
#define CBITPERUSHORT 16
//+-------------------------------------------------------------------------
//
// Class: SDeltaBlock (db)
//
// Purpose: A single block of delta list entries.
//
// Interface:
//
// History: 10-Jul-92 PhilipLa Created.
//
// Notes:
//
//--------------------------------------------------------------------------
struct SDeltaBlock
{
public:
#ifndef _MAC
inline
#endif
SDeltaBlock();
#ifndef _MAC
inline
#endif
void *operator new(size_t size, IMalloc * const pMalloc);
inline const BOOL IsOwned(const USHORT uOffset);
inline void MakeOwn(const USHORT uOffset);
inline void DisOwn(const USHORT uOffset);
SECT _sect[CSECTPERBLOCK];
USHORT _fOwn[(CSECTPERBLOCK / CBITPERUSHORT)];
};
SAFE_DFBASED_PTR(CBasedDeltaBlockPtr, SDeltaBlock);
SAFE_DFBASED_PTR(CBasedDeltaBlockPtrPtr, CBasedDeltaBlockPtr);
inline const BOOL SDeltaBlock::IsOwned(const USHORT uOffset)
{
msfAssert(uOffset < CSECTPERBLOCK);
return (_fOwn[uOffset / CBITPERUSHORT] &
(1 << (uOffset % CBITPERUSHORT))) != 0;
}
inline void SDeltaBlock::MakeOwn(const USHORT uOffset)
{
msfAssert(uOffset < CSECTPERBLOCK);
msfAssert(!IsOwned(uOffset));
msfAssert((uOffset / CBITPERUSHORT) < (CSECTPERBLOCK / CBITPERUSHORT));
_fOwn[uOffset / CBITPERUSHORT] |= (1 << (uOffset % CBITPERUSHORT));
}
inline void SDeltaBlock::DisOwn(const USHORT uOffset)
{
msfAssert(uOffset < CSECTPERBLOCK);
msfAssert(IsOwned(uOffset));
msfAssert((uOffset / CBITPERUSHORT) < (CSECTPERBLOCK / CBITPERUSHORT));
_fOwn[uOffset / CBITPERUSHORT] &= ~(1 << (uOffset % CBITPERUSHORT));
}
//+-------------------------------------------------------------------------
//
// Class: CDeltaList (dl)
//
// Purpose: Delta list for transacted streans.
//
// Interface:
//
// History: 21-Jan-92 PhilipLa Created.
//
// Notes:
//
//--------------------------------------------------------------------------
class CDeltaList
{
public:
CDeltaList(CMStream *pms, CMStream *pmsScratch);
#ifdef LARGE_STREAMS
SCODE Init(ULONGLONG ulSize, CTransactedStream *ptsParent);
SCODE InitResize(ULONGLONG ulSize);
#else
SCODE Init(ULONG ulSize, CTransactedStream *ptsParent);
SCODE InitResize(ULONG ulSize);
#endif
~CDeltaList();
SCODE GetMap(SECT sectOld, const DWORD dwFlags, SECT *psectRet);
void BeginCommit(CTransactedStream *ptsParent);
void EndCommit(CDeltaList *pdlNew, DFLAGS df);
inline ILockBytes *GetDataILB(void);
inline ILockBytes *GetControlILB(void);
inline CFat * GetDataFat(void);
inline CFat * GetControlFat(void);
inline USHORT GetDataSectorSize(void);
inline USHORT GetDataSectorShift(void);
inline USHORT GetControlSectorSize(void);
void Empty(void);
inline BOOL IsEmpty(void);
inline BOOL IsInMemory(void);
inline BOOL IsInStream(void);
inline BOOL IsNoScratch(void);
SCODE IsOwned(SECT sect, SECT sectMap, BOOL *fOwn);
inline CMStream * GetMStream();
SCODE ReleaseInvalidSects(SECT sectMaxValid);
private:
CBasedDeltaBlockPtrPtr _apdb;
ULONG _ulSize;
CBasedMStreamPtr _pmsScratch;
CBasedMStreamPtr _pms;
CBasedTransactedStreamPtr _ptsParent;
SECT _sectStart;
SCODE InitStreamBlock(ULONG ul);
SCODE ReadMap(SECT *psectStart, SECT sect, SECT *psectRet);
SCODE WriteMap(SECT *psectStart, SECT sect, SECT sectMap);
void FreeStream(SECT sectStart, ULONG ulSize);
SCODE FindOffset(
SECT *psectStart,
SECT sect,
ULARGE_INTEGER *pulRet,
BOOL fWrite);
SCODE DumpList(void);
#if DBG == 1
void PrintList(void);
#endif
void ReleaseBlock(ULONG oBlock);
inline CBasedDeltaBlockPtr * GetNewDeltaArray(ULONG ulSize);
};
SAFE_DFBASED_PTR(CBasedDeltaListPtr, CDeltaList);
//-----------------
inline CMStream * CDeltaList::GetMStream()
{
if (!IsNoScratch())
return _pmsScratch;
else
return _pms;
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetDataILB, public
//
// Synopsis: Return pointer to ILockBytes for storing data
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline ILockBytes * CDeltaList::GetDataILB(void)
{
if (_pms)
return _pms->GetILB();
else
return _pmsScratch->GetILB();
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetControlILB, public
//
// Synopsis: Return pointer to ILockBytes for storing control information
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline ILockBytes * CDeltaList::GetControlILB(void)
{
return _pmsScratch->GetILB();
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetDataFat, public
//
// Synopsis: Return pointer to fat to use for storing stream data
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline CFat * CDeltaList::GetDataFat(void)
{
if (_pms)
return _pmsScratch->GetMiniFat();
else
return _pmsScratch->GetFat();
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetControlFat, public
//
// Synopsis: Return pointer to fat to use for storing control information
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline CFat * CDeltaList::GetControlFat(void)
{
return _pmsScratch->GetFat();
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetDataSectorSize, public
//
// Synopsis: Return sector size for storing stream data
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline USHORT CDeltaList::GetDataSectorSize(void)
{
if (_pms)
return _pms->GetSectorSize();
else
return _pmsScratch->GetSectorSize();
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetDataSectorShift, public
//
// Synopsis: Return sector size for storing stream data
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline USHORT CDeltaList::GetDataSectorShift(void)
{
if (_pms)
return _pms->GetSectorShift();
else
return _pmsScratch->GetSectorShift();
}
//+-------------------------------------------------------------------------
//
// Method: CDeltaList::GetControlSectorSize, public
//
// Synopsis: Return sector size for storing control information
//
// History: 10-Jul-92 PhilipLa Created.
//
//--------------------------------------------------------------------------
inline USHORT CDeltaList::GetControlSectorSize(void)
{
return _pmsScratch->GetSectorSize();
}
//+---------------------------------------------------------------------------
//
// Member: CDeltaList::IsNoScratch, public
//
// Synopsis: Return TRUE if the delta list is in no-scratch mode
//
// Arguments: None.
//
// History: 19-Nov-92 PhilipLa Created
//
//----------------------------------------------------------------------------
inline BOOL CDeltaList::IsNoScratch(void)
{
return (_pms != NULL);
}
//+---------------------------------------------------------------------------
//
// Member: CDeltaList::IsEmpty, public
//
// Synopsis: Return TRUE if the delta list contains no changes.
//
// Arguments: None.
//
// History: 19-Nov-92 PhilipLa Created
//
//----------------------------------------------------------------------------
inline BOOL CDeltaList::IsEmpty(void)
{
return ((_apdb == NULL) && (_sectStart == ENDOFCHAIN));
}
//+---------------------------------------------------------------------------
//
// Member: CDeltaList::IsInMemory, public
//
// Synopsis: Return TRUE if the delta list is in memory
//
// Arguments: None.
//
// History: 19-Nov-92 PhilipLa Created
//
//----------------------------------------------------------------------------
inline BOOL CDeltaList::IsInMemory(void)
{
return (_apdb != NULL);
}
//+---------------------------------------------------------------------------
//
// Member: CDeltaList::IsInStream, public
//
// Synopsis: Return TRUE if the delta list is in a stream
//
// Arguments: None.
//
// History: 19-Nov-92 PhilipLa Created
//
//----------------------------------------------------------------------------
inline BOOL CDeltaList::IsInStream(void)
{
return ((_apdb == NULL) && (_sectStart != ENDOFCHAIN));
}
#endif //__DL_HXX__