#if !defined( _MEMSTM_H_ )
#define _MEMSTM_H_

class	CMarshalMemStm;
class	CMarshalMemBytes;

//  function prototypes
STDAPI_(LPSTREAM) CreateMemStm(DWORD cb, LPHANDLE phMem);
STDAPI_(LPLOCKBYTES) CreateMemLockBytes(DWORD cb, LPHANDLE phMem);


// CMemStm is a stream implementation on top of global shared memory MEMSTM
//
// CMemStm
// +---------+
// + pvtf    +    Shared  memory
// +---------+	 +--------------+
// + m_pMem  +-->|cb            |
// +---------+   |cRef          |
//               |hGlobal       |--->+--------------+
//               +--------------+	 | Actual Data	|
// CMemStm	       MEMSTM		 +--------------+
//
struct MEMSTM
{
    DWORD cb;               // Size of buf[]
    DWORD cRef;             // See below
    BYTE buf[4];            // The data
};

// cRef counts all CMemStm pointers to this MEMSTM plus the number of times
// a hMem handle to MEMSTM had been returned



class	CMemStm : public IStream
{
public:
    CMemStm() { m_hMem = NULL; m_pData = NULL; m_pos = 0; m_refs = 0; }
    ~CMemStm() {}

    STDMETHOD(QueryInterface) (REFIID iidInterface, void  *  * ppvObj);
    STDMETHOD_(ULONG,AddRef) (void);
    STDMETHOD_(ULONG,Release) (void);


    STDMETHOD(Read) (VOID HUGEP* pv, ULONG cb, ULONG *pcbRead);
    STDMETHOD(Write) (VOID const HUGEP* pv, ULONG cb, ULONG *pcbWritten);
    STDMETHOD(Seek) (LARGE_INTEGER dlibMove,
		     DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition);
    STDMETHOD(SetSize) (ULARGE_INTEGER cb);
    STDMETHOD(CopyTo) (IStream *pstm, ULARGE_INTEGER cb,
		       ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten);
    STDMETHOD(Commit) (DWORD grfCommitFlags);
    STDMETHOD(Revert) (void);
    STDMETHOD(LockRegion) (ULARGE_INTEGER libOffset, ULARGE_INTEGER cb,
			   DWORD dwLockType);
    STDMETHOD(UnlockRegion) (ULARGE_INTEGER libOffset, ULARGE_INTEGER cb,
			     DWORD dwLockType);
    STDMETHOD(Stat) (STATSTG *pstatstg, DWORD statflag);
    STDMETHOD(Clone)(IStream **ppstm);

    static CMemStm *Create(HANDLE hMem);

private:
    ULONG	m_refs;	     // Number of references to this CmemStm
    ULONG	m_pos;	     // Seek pointer for Read/Write
    HANDLE	m_hMem;	     // Memory Handle passed on creation
    MEMSTM  *	m_pData;     // Pointer to that memroy

    friend class CMarshalMemStm;
};




// CMemBytes is an ILockBytes implementation on top of global shared
// memory MEMBYTES
//
// CMemBytes
// +---------+
// + pvtf    +    Shared  memory
// +---------+   +--------------+
// + m_pData +-->| cb           |	 
// +---------+   | cRef         |	 
//               | hGlobal      |--->+-------------+
//               +--------------+	 | Actual data |
// CMemBytes         MEMBYTES			 +-------------+
//
struct MEMBYTES     // Bookeeping info in shared memory
{
    DWORD	cRef;		    // See below
    DWORD	cb;		    // Size of hGlobal
    HANDLE	hGlobal;	    // The data
    BOOL	fDeleteOnRelease;
};

#define LOCKBYTE_SIG (0x0046574A)

// cRef counts all CMemBytes pointers to this MEMBYTES. 
// It and fDeleteOnRelease control the GlobalFreeing of the hGlobal.



class	CMemBytes : public ILockBytes
{
public:
    CMemBytes() {m_hMem = NULL; m_pData = NULL; m_refs = 0;}
    ~CMemBytes() {}

    STDMETHOD(QueryInterface) (REFIID iidInterface, void **ppvObj);
    STDMETHOD_(ULONG,AddRef) (void);
    STDMETHOD_(ULONG,Release) (void);


    STDMETHOD(ReadAt) (ULARGE_INTEGER ulOffset, VOID HUGEP *pv, ULONG cb,
		       ULONG *pcbRead);
    STDMETHOD(WriteAt) (ULARGE_INTEGER ulOffset, VOID const HUGEP *pv,
			ULONG cb, ULONG *pcbWritten);
    STDMETHOD(Flush) (void);
    STDMETHOD(SetSize) (ULARGE_INTEGER cb);
    STDMETHOD(LockRegion) (ULARGE_INTEGER libOffset, ULARGE_INTEGER cb,
			   DWORD dwLockType);
    STDMETHOD(UnlockRegion) (ULARGE_INTEGER libOffset, ULARGE_INTEGER cb,
			     DWORD dwLockType);
    STDMETHOD(Stat) (STATSTG *pstatstg, DWORD statflag);

    static CMemBytes *Create(HANDLE hMem);

private:
    DWORD	m_dwSig;	// Signature indicating this is our
				// implementation of ILockBytes: LOCKBYTE_SIG
    ULONG	m_refs;		// Normal reference count
    HANDLE	m_hMem;		// Handle for bookeeping info (MEMBYTES)
    MEMBYTES  * m_pData;	// Pointer to that memroy

//    friend GetHGlobalFromILockBytes(LPLOCKBYTES, HGLOBAL *);
    friend class CMarshalMemBytes;
};


// CMarshalMemStm can Marshal, Unmarshal CMemStm.  It is impletented as
// a seperate object accessible from CMemStm, CMemBytes: QueryIntreface of
// IMarshal on CMemStm's IStream will return an IMarshal pointer to
// CMarshalMemStm, but QueryInterface of IStream on that IMarshal will
// fail.
//
// Also QueryInterface of IUnknown on IMarshal will not return the same value
// As QueryInterface of IUnkown on the original IStream.
//
class	CMarshalMemStm : public IMarshal
{
public:
    CMarshalMemStm() {m_pMemStm = NULL; m_refs = 0; }
    ~CMarshalMemStm() {}

    STDMETHOD(QueryInterface) (REFIID riid, LPVOID  * ppvObj);
    STDMETHOD_(ULONG,AddRef) (void);
    STDMETHOD_(ULONG,Release) (void);

    STDMETHOD(GetUnmarshalClass)(THIS_ REFIID riid, LPVOID pv,
				DWORD dwDestContext, LPVOID pvDestContext,
				DWORD mshlflags, LPCLSID pCid);
    STDMETHOD(GetMarshalSizeMax)(THIS_ REFIID riid, LPVOID pv,
				DWORD dwDestContext, LPVOID pvDestContext,
				DWORD mshlflags, LPDWORD pSize);
    STDMETHOD(MarshalInterface)(THIS_ IStream  * pStm, REFIID riid,
				LPVOID pv, DWORD dwDestContext, LPVOID pvDestContext,
				DWORD mshlflags);
    STDMETHOD(UnmarshalInterface)(THIS_ IStream  * pStm, REFIID riid,
			LPVOID	* ppv);
    STDMETHOD(ReleaseMarshalData)(THIS_ IStream  * pStm);
    STDMETHOD(DisconnectObject)(THIS_ DWORD dwReserved);

    static CMarshalMemStm * Create(CMemStm *pMemStm);

private:
    ULONG	m_refs;		// Number of references to this CmemStm
    CMemStm  *	m_pMemStm;	// Pointer to object [Un]Marshalled
    CLSID	m_clsid;	// Class of object pointed by pUnk
};


// CMarshalMemBytes can Marshal, Unmarshal CMemBytes.  It is impletented as
// a seperate object accessible from CMemBytes, CMemBytes: QueryIntreface of
// IMarshal on CMemBytes's ILocBytes will return an IMarshal pointer to
// CMarshalMemBytes, but QueryInterface of ILockBytes on that IMarshal will
// fail.
//
// Also QueryInterface of IUnknown on IMarshal will not return the same value
// as QueryInterface of IUnknown on the original ILockBytes.
//
class	CMarshalMemBytes : public IMarshal
{
public:
    CMarshalMemBytes() {m_pMemBytes = NULL; m_refs = 0;}
    ~CMarshalMemBytes() {}

    STDMETHOD(QueryInterface) (REFIID riid, LPVOID  * ppvObj);
    STDMETHOD_(ULONG,AddRef) (void);
    STDMETHOD_(ULONG,Release) (void);

    STDMETHOD(GetUnmarshalClass)(THIS_ REFIID riid, LPVOID pv,
				DWORD dwDestContext, LPVOID pvDestContext,
				DWORD mshlflags, LPCLSID pCid);
    STDMETHOD(GetMarshalSizeMax)(THIS_ REFIID riid, LPVOID pv,
				DWORD dwDestContext, LPVOID pvDestContext,
				DWORD mshlflags, LPDWORD pSize);
    STDMETHOD(MarshalInterface)(THIS_ IStream  * pStm, REFIID riid,
				LPVOID pv, DWORD dwDestContext, LPVOID pvDestContext,
				DWORD mshlflags);
    STDMETHOD(UnmarshalInterface)(THIS_ IStream  * pStm, REFIID riid,
			LPVOID	* ppv);
    STDMETHOD(ReleaseMarshalData)(THIS_ IStream  * pStm);
    STDMETHOD(DisconnectObject)(THIS_ DWORD dwReserved);

    static CMarshalMemBytes* Create(CMemBytes *pMemBytes);

private:
    ULONG	m_refs;		// Number of references to this CMemBytes
    CMemBytes  *m_pMemBytes;	// Pointer to object [Un]Marshalled
    CLSID	m_clsid;	// Class of object pointed by pUnk
};


#endif // _MEMSTM_H_