650 lines
16 KiB
C++
650 lines
16 KiB
C++
//+--------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1992
|
|
//
|
|
// File: dfbasis.hxx
|
|
//
|
|
// Contents: DocFile basis block class
|
|
//
|
|
// Classes: CDFBasis
|
|
//
|
|
// History: 26-Feb-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
#ifndef __DFBASIS_HXX__
|
|
#define __DFBASIS_HXX__
|
|
|
|
#include <dfmsp.hxx>
|
|
#include <msf.hxx>
|
|
#include <context.hxx>
|
|
#include <freelist.hxx>
|
|
|
|
interface ILockBytes;
|
|
class CPubDocFile;
|
|
class CDocFile;
|
|
SAFE_DFBASED_PTR(CBasedPubDocFilePtr, CPubDocFile);
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Class: CDFBasis (dfb)
|
|
//
|
|
// Purpose: Defines base variables for sharing between exposed
|
|
// DocFiles
|
|
//
|
|
// History: 26-Feb-92 DrewB Created
|
|
// 18-May-93 AlexT Added CMallocBased
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
typedef enum
|
|
{
|
|
CDFB_DIRECTDOCFILE = 0,
|
|
CDFB_DIRECTSTREAM = 1,
|
|
CDFB_WRAPPEDDOCFILE = 2,
|
|
CDFB_TRANSACTEDSTREAM = 3
|
|
} CDFB_CLASSTYPE;
|
|
|
|
#define CDFB_CLASSCOUNT 4
|
|
|
|
class CDFBasis : public CMallocBased
|
|
{
|
|
public:
|
|
inline CDFBasis(IMalloc * const pMalloc, DFLAGS df,
|
|
DWORD dwLockFlags, CGlobalContext *pgc);
|
|
inline ~CDFBasis(void);
|
|
|
|
void vRelease(void);
|
|
inline void vAddRef(void);
|
|
|
|
inline void SetAccess(CPerContext *ppc);
|
|
inline void ClearAccess(void);
|
|
inline ULONG CountContexts(void);
|
|
|
|
inline ILockBytes **GetPBase(void);
|
|
inline ILockBytes *GetBase(void);
|
|
inline CFileStream **GetPDirty(void);
|
|
inline CFileStream *GetDirty(void);
|
|
inline ILockBytes *GetOriginal(void);
|
|
inline void SetBase(ILockBytes *plkb);
|
|
inline void SetDirty(CFileStream *pfst);
|
|
inline void SetOriginal(ILockBytes *plkb);
|
|
inline void SetContext(CPerContext *ppc);
|
|
|
|
inline DWORD GetOrigLockFlags(void);
|
|
|
|
inline ULONG GetNewTemp(void);
|
|
inline DFSIGNATURE GetNewSig(void);
|
|
|
|
inline CMStream *GetScratch(void);
|
|
inline void SetScratch(CMStream *pms);
|
|
|
|
inline CMStream *GetBaseMultiStream(void);
|
|
inline void SetBaseMultiStream(CMStream *pms);
|
|
|
|
inline CPubDocFile *GetCopyBase(void);
|
|
inline void SetCopyBase(CPubDocFile *pdf);
|
|
|
|
inline CFreeList *GetFreeList(CDFB_CLASSTYPE classtype);
|
|
inline SCODE Reserve(UINT cItems, CDFB_CLASSTYPE classtype);
|
|
inline void CDFBasis::Unreserve(UINT cItems, CDFB_CLASSTYPE classtype);
|
|
|
|
inline DFLAGS GetOpenFlags(void);
|
|
inline IMalloc *GetMalloc(void);
|
|
|
|
#ifdef DIRECTWRITERLOCK
|
|
HRESULT WaitForWriteAccess (DWORD dwTimeout, CGlobalContext *pgc);
|
|
HRESULT ReleaseWriteAccess ();
|
|
inline BOOL DirectWriterMode ();
|
|
inline BOOL HaveWriteAccess ();
|
|
#endif
|
|
|
|
private:
|
|
CBasedMStreamPtr _pms;
|
|
CBasedMStreamPtr _pmsScratch;
|
|
DFLAGS const _dfOpen;
|
|
ILockBytes *_plkbBase;
|
|
CFileStream *_pfstDirty;
|
|
ILockBytes *_plkbOriginal;
|
|
LONG _cReferences;
|
|
ULONG _cTemps;
|
|
DFSIGNATURE _cSigs;
|
|
CBasedPubDocFilePtr _pdfCopyBase;
|
|
CBasedGlobalContextPtr _pgcGlobalContext;
|
|
|
|
DWORD _dwOrigLocks;
|
|
|
|
CFreeList _afrl[CDFB_CLASSCOUNT];
|
|
static size_t _aReserveSize[CDFB_CLASSCOUNT];
|
|
|
|
#ifdef DIRECTWRITERLOCK
|
|
HRESULT TryReadLocks (CGlobalContext *pgc, ULONG ulMask);
|
|
BOOL _fDirectWriterMode;
|
|
BOOL _fWriteLocked;
|
|
#endif
|
|
|
|
IMalloc * const _pMalloc;
|
|
};
|
|
SAFE_DFBASED_PTR(CBasedDFBasisPtr, CDFBasis);
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::CDFBasis, public
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CDFBasis::CDFBasis(IMalloc * const pMalloc, DFLAGS df,
|
|
DWORD dwLockFlags, CGlobalContext *pgc)
|
|
: _pMalloc(pMalloc), _dfOpen(df)
|
|
{
|
|
_cReferences = 1;
|
|
_cTemps = 0;
|
|
_cSigs = 0;
|
|
_pdfCopyBase = NULL;
|
|
_plkbBase = NULL;
|
|
_pfstDirty = NULL;
|
|
_plkbOriginal = NULL;
|
|
_dwOrigLocks = dwLockFlags;
|
|
_pms = NULL;
|
|
_pmsScratch = NULL;
|
|
#ifdef DIRECTWRITERLOCK
|
|
_fDirectWriterMode = P_READWRITE(df) && !P_TRANSACTED(df) &&
|
|
!P_DENYREAD(df) && P_DENYWRITE(df);
|
|
_fWriteLocked = FALSE;
|
|
#endif
|
|
_pgcGlobalContext = pgc;
|
|
_pgcGlobalContext->AddRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::~CDFBasis, public
|
|
//
|
|
// Synopsis: Destructor
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CDFBasis::~CDFBasis(void)
|
|
{
|
|
delete BP_TO_P(CMStream *, _pmsScratch);
|
|
_pgcGlobalContext->Release();
|
|
msfAssert(_cReferences == 0);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::AddRef, public
|
|
//
|
|
// Synopsis: Increase reference count
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::vAddRef(void)
|
|
{
|
|
InterlockedIncrement(&_cReferences);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetAccess, public
|
|
//
|
|
// Synopsis: Takes semaphore and sets pointers
|
|
//
|
|
// Arguments: [ppc] - Context
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetAccess(CPerContext *ppc)
|
|
{
|
|
SetContext(ppc);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::ClearAccess, public
|
|
//
|
|
// Synopsis: Releases semaphore and resets pointers
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::ClearAccess(void)
|
|
{
|
|
#if DBG == 1
|
|
_plkbBase = NULL;
|
|
_pfstDirty = NULL;
|
|
#endif
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetPBase, public
|
|
//
|
|
// Synopsis: Returns a pointer to _plstBase
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline ILockBytes **CDFBasis::GetPBase(void)
|
|
{
|
|
return &_plkbBase;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetPDirty, public
|
|
//
|
|
// Synopsis: Returns a pointer to _plstDirty
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CFileStream **CDFBasis::GetPDirty(void)
|
|
{
|
|
return &_pfstDirty;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetBase, public
|
|
//
|
|
// Synopsis: Returns _plstBase
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline ILockBytes *CDFBasis::GetBase(void)
|
|
{
|
|
return _plkbBase;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetBase, public
|
|
//
|
|
// Synopsis: Sets the base
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetBase(ILockBytes *plkb)
|
|
{
|
|
_plkbBase = plkb;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetDirty, public
|
|
//
|
|
// Synopsis: Returns _plstDirty
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CFileStream *CDFBasis::GetDirty(void)
|
|
{
|
|
return _pfstDirty;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetDirty, public
|
|
//
|
|
// Synopsis: Sets the Dirty
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetDirty(CFileStream *pfst)
|
|
{
|
|
_pfstDirty = pfst;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetOriginal, public
|
|
//
|
|
// Synopsis: Returns _plstOriginal
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline ILockBytes *CDFBasis::GetOriginal(void)
|
|
{
|
|
return _plkbOriginal;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetOriginal, public
|
|
//
|
|
// Synopsis: Sets the Original
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetOriginal(ILockBytes *plkb)
|
|
{
|
|
_plkbOriginal = plkb;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetContext, public
|
|
//
|
|
// Synopsis: Sets the context
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetContext(CPerContext *ppc)
|
|
{
|
|
_plkbBase = ppc->GetBase();
|
|
_pfstDirty = ppc->GetDirty();
|
|
_plkbOriginal = ppc->GetOriginal();
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetContextCount, public
|
|
//
|
|
// Synopsis: Returns the number of contexts. This can be compared against
|
|
// The number of locks on the file to determine if there are any
|
|
// seperate opens.
|
|
//
|
|
// History: 17-Mar-97 BChapman Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline ULONG CDFBasis::CountContexts(void)
|
|
{
|
|
return _pgcGlobalContext->CountContexts();
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetNewTemp, public
|
|
//
|
|
// Synopsis: Return _cTemps++
|
|
//
|
|
// History: 03-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline ULONG CDFBasis::GetNewTemp(void)
|
|
{
|
|
return _cTemps++;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetNewSig, public
|
|
//
|
|
// Synopsis: Return _cSigs++
|
|
//
|
|
// History: 03-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline DFSIGNATURE CDFBasis::GetNewSig(void)
|
|
{
|
|
return _cSigs++;
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetCopyBase, public
|
|
//
|
|
// Synopsis: Returns _pdfCopyBase
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CPubDocFile *CDFBasis::GetCopyBase(void)
|
|
{
|
|
return BP_TO_P(CPubDocFile *, _pdfCopyBase);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetCopyBase, public
|
|
//
|
|
// Synopsis: Sets _pdfCopyBase
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetCopyBase(CPubDocFile *pdf)
|
|
{
|
|
_pdfCopyBase = P_TO_BP(CBasedPubDocFilePtr, pdf);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetScratch, public
|
|
//
|
|
// Synopsis: Returns handle to scratch multistream
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CMStream * CDFBasis::GetScratch(void)
|
|
{
|
|
return BP_TO_P(CMStream *, _pmsScratch);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetScratch, public
|
|
//
|
|
// Synopsis: Sets scratch MS
|
|
//
|
|
// History: 02-Mar-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetScratch(CMStream *pms)
|
|
{
|
|
_pmsScratch = P_TO_BP(CBasedMStreamPtr, pms);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetBaseMultiStream, public
|
|
//
|
|
// Synopsis: Returns pointer to base multistream
|
|
//
|
|
// History: 25-Feb-95 PhilipLa Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline CMStream * CDFBasis::GetBaseMultiStream(void)
|
|
{
|
|
return BP_TO_P(CMStream *, _pms);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::SetBaseMultiStream, public
|
|
//
|
|
// Synopsis: Sets base MS
|
|
//
|
|
// History: 25-Feb-95 PhilipLa Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline void CDFBasis::SetBaseMultiStream(CMStream *pms)
|
|
{
|
|
_pms = P_TO_BP(CBasedMStreamPtr, pms);
|
|
}
|
|
|
|
//+--------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetOrigLockFlags, public
|
|
//
|
|
// Synopsis: Returns the original's lock flags
|
|
//
|
|
// History: 11-Sep-92 DrewB Created
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
inline DWORD CDFBasis::GetOrigLockFlags(void)
|
|
{
|
|
return _dwOrigLocks;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetOpenFlags
|
|
//
|
|
// Synopsis: Returns access/share flags
|
|
//
|
|
// History: 21-Dec-92 AlexT Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
inline DFLAGS CDFBasis::GetOpenFlags(void)
|
|
{
|
|
return(_dfOpen);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetFreeList, public
|
|
//
|
|
// Synopsis: Gets the free list for the indicated reserved type
|
|
//
|
|
// History: 05-Nov-92 DrewB Created
|
|
// 18-May-93 AlexT Switch to array
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline CFreeList *CDFBasis::GetFreeList(CDFB_CLASSTYPE classtype)
|
|
{
|
|
msfAssert(classtype >= 0 && classtype <= CDFB_CLASSCOUNT);
|
|
return &_afrl[classtype];
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::Reserve, public
|
|
//
|
|
// Synopsis: Reserve memory for instances
|
|
//
|
|
// Arguments: [cItems] -- count of items to reserve
|
|
// [classtype] -- class of items to reserve
|
|
//
|
|
// History: 21-May-93 AlexT Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline SCODE CDFBasis::Reserve(UINT cItems, CDFB_CLASSTYPE classtype)
|
|
{
|
|
msfAssert(classtype >= 0 && classtype <= CDFB_CLASSCOUNT);
|
|
return _afrl[classtype].Reserve(_pMalloc,
|
|
cItems,
|
|
_aReserveSize[classtype]);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::Unreserve, public
|
|
//
|
|
// Synopsis: Unreserve memory for instances
|
|
//
|
|
// Arguments: [cItems] -- count of items to unreserve
|
|
// [classtype] -- class of items to unreserve
|
|
//
|
|
// History: 21-May-93 AlexT Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline void CDFBasis::Unreserve(UINT cItems, CDFB_CLASSTYPE classtype)
|
|
{
|
|
msfAssert(classtype >= 0 && classtype <= CDFB_CLASSCOUNT);
|
|
_afrl[classtype].Unreserve(cItems);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::GetMalloc, public
|
|
//
|
|
// Synopsis: Return allocator associated with basis
|
|
//
|
|
// History: 21-May-93 AlexT Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline IMalloc *CDFBasis::GetMalloc(void)
|
|
{
|
|
#ifdef MULTIHEAP
|
|
//We can't return the _pMalloc pointer here, since it's only valid
|
|
// in the creating process. What we really want to return in the
|
|
// pointer to the current allocator, which is always &g_smAllocator.
|
|
//return (IMalloc *)_pMalloc;
|
|
return (IMalloc *)&g_smAllocator;
|
|
#else
|
|
return (IMalloc *)_pMalloc;
|
|
#endif
|
|
}
|
|
|
|
#ifdef DIRECTWRITERLOCK
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::DirectWriterMode, public
|
|
//
|
|
// Synopsis: indicates if this is readwrite deny write
|
|
//
|
|
// History: 11-Aug-1996 HenryLee created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
inline BOOL CDFBasis::DirectWriterMode ()
|
|
{
|
|
return _fDirectWriterMode;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CDFBasis::HaveWriteLock, public
|
|
//
|
|
// Synopsis: indicates if this if someone is holding the exclusive writelock
|
|
//
|
|
// History: 11-Aug-1996 HenryLee created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
inline BOOL CDFBasis::HaveWriteAccess ()
|
|
{
|
|
return _fWriteLocked;
|
|
}
|
|
#endif
|
|
|
|
#endif
|