2 * Compound Storage (32 bit version)
4 * Implemented using the documentation of the LAOLA project at
5 * <URL:http://wwwwbs.cs.tu-berlin.de/~schwartz/pmh/index.html>
6 * (Thanks to Martin Schwartz <schwartz@cs.tu-berlin.de>)
8 * This include file contains definitions of types and function
9 * prototypes that are used in the many files implementing the
10 * storage functionality
12 * Copyright 1998,1999 Francis Beaudet
13 * Copyright 1998,1999 Thuy Nguyen
15 #ifndef __STORAGE32_H__
16 #define __STORAGE32_H__
20 #include "wine/obj_base.h"
21 #include "wine/obj_storage.h"
24 * Definitions for the file format offsets.
26 static const ULONG OFFSET_BIGBLOCKSIZEBITS
= 0x0000001e;
27 static const ULONG OFFSET_SMALLBLOCKSIZEBITS
= 0x00000020;
28 static const ULONG OFFSET_BBDEPOTCOUNT
= 0x0000002C;
29 static const ULONG OFFSET_ROOTSTARTBLOCK
= 0x00000030;
30 static const ULONG OFFSET_SBDEPOTSTART
= 0x0000003C;
31 static const ULONG OFFSET_EXTBBDEPOTSTART
= 0x00000044;
32 static const ULONG OFFSET_EXTBBDEPOTCOUNT
= 0x00000048;
33 static const ULONG OFFSET_BBDEPOTSTART
= 0x0000004C;
34 static const ULONG OFFSET_PS_NAME
= 0x00000000;
35 static const ULONG OFFSET_PS_NAMELENGTH
= 0x00000040;
36 static const ULONG OFFSET_PS_PROPERTYTYPE
= 0x00000042;
37 static const ULONG OFFSET_PS_PREVIOUSPROP
= 0x00000044;
38 static const ULONG OFFSET_PS_NEXTPROP
= 0x00000048;
39 static const ULONG OFFSET_PS_DIRPROP
= 0x0000004C;
40 static const ULONG OFFSET_PS_GUID
= 0x00000050;
41 static const ULONG OFFSET_PS_TSS1
= 0x00000064;
42 static const ULONG OFFSET_PS_TSD1
= 0x00000068;
43 static const ULONG OFFSET_PS_TSS2
= 0x0000006C;
44 static const ULONG OFFSET_PS_TSD2
= 0x00000070;
45 static const ULONG OFFSET_PS_STARTBLOCK
= 0x00000074;
46 static const ULONG OFFSET_PS_SIZE
= 0x00000078;
47 static const WORD DEF_BIG_BLOCK_SIZE_BITS
= 0x0009;
48 static const WORD DEF_SMALL_BLOCK_SIZE_BITS
= 0x0006;
49 static const WORD DEF_BIG_BLOCK_SIZE
= 0x0200;
50 static const WORD DEF_SMALL_BLOCK_SIZE
= 0x0040;
51 static const ULONG BLOCK_EXTBBDEPOT
= 0xFFFFFFFC;
52 static const ULONG BLOCK_SPECIAL
= 0xFFFFFFFD;
53 static const ULONG BLOCK_END_OF_CHAIN
= 0xFFFFFFFE;
54 static const ULONG BLOCK_UNUSED
= 0xFFFFFFFF;
55 static const ULONG PROPERTY_NULL
= 0xFFFFFFFF;
57 #define PROPERTY_NAME_MAX_LEN 0x20
58 #define PROPERTY_NAME_BUFFER_LEN 0x40
60 #define PROPSET_BLOCK_SIZE 0x00000080
63 * Property type of relation
65 #define PROPERTY_RELATION_PREVIOUS 0
66 #define PROPERTY_RELATION_NEXT 1
67 #define PROPERTY_RELATION_DIR 2
70 * Property type constants
72 #define PROPTYPE_STORAGE 0x01
73 #define PROPTYPE_STREAM 0x02
74 #define PROPTYPE_ROOT 0x05
77 * These defines assume a hardcoded blocksize. The code will assert
78 * if the blocksize is different. Some changes will have to be done if it
81 #define BIG_BLOCK_SIZE 0x200
82 #define COUNT_BBDEPOTINHEADER 109
83 #define LIMIT_TO_USE_SMALL_BLOCK 0x1000
84 #define NUM_BLOCKS_PER_DEPOT_BLOCK 128
87 * These are signatures to detect the type of Document file.
89 static const BYTE STORAGE_magic
[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
90 static const BYTE STORAGE_oldmagic
[8] ={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
93 * Forward declarations of all the structures used by the storage
96 typedef struct StorageBaseImpl StorageBaseImpl
;
97 typedef struct StorageImpl StorageImpl
;
98 typedef struct StorageInternalImpl StorageInternalImpl
;
99 typedef struct BlockChainStream BlockChainStream
;
100 typedef struct SmallBlockChainStream SmallBlockChainStream
;
101 typedef struct IEnumSTATSTGImpl IEnumSTATSTGImpl
;
102 typedef struct StgProperty StgProperty
;
103 typedef struct StgStreamImpl StgStreamImpl
;
106 * This utility structure is used to read/write the information in a storage
111 WCHAR name
[PROPERTY_NAME_MAX_LEN
];
112 WORD sizeOfNameString
;
114 ULONG previousProperty
;
117 GUID propertyUniqueID
;
126 /*************************************************************************
127 * Big Block File support
129 * The big block file is an abstraction of a flat file separated in
130 * same sized blocks. The implementation for the methods described in
131 * this section appear in stg_bigblockfile.c
135 * Declaration of the data structures
137 typedef struct BigBlockFile BigBlockFile
,*LPBIGBLOCKFILE
;
138 typedef struct MappedPage MappedPage
,*LPMAPPEDPAGE
;
143 ULARGE_INTEGER filesize
;
149 MappedPage
*victimhead
, *victimtail
;
150 ULONG num_victim_pages
;
157 * Declaration of the functions used to manipulate the BigBlockFile
160 BigBlockFile
* BIGBLOCKFILE_Construct(HANDLE hFile
,
165 void BIGBLOCKFILE_Destructor(LPBIGBLOCKFILE This
);
166 void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This
, ULONG index
);
167 void* BIGBLOCKFILE_GetROBigBlock(LPBIGBLOCKFILE This
, ULONG index
);
168 void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This
, void *pBlock
);
169 void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This
, ULARGE_INTEGER newSize
);
170 ULARGE_INTEGER
BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This
);
172 /*************************************************************************
173 * Ole Convert support
176 void OLECONVERT_CreateOleStream(LPSTORAGE pStorage
);
177 HRESULT
OLECONVERT_CreateCompObjStream(LPSTORAGE pStorage
, LPCSTR strOleTypeName
);
179 /****************************************************************************
180 * Storage32BaseImpl definitions.
182 * This stucture defines the base information contained in all implementations
183 * of IStorage32 contained in this filee storage implementation.
185 * In OOP terms, this is the base class for all the IStorage32 implementations
186 * contained in this file.
188 struct StorageBaseImpl
190 ICOM_VFIELD(IStorage
); /* Needs to be the first item in the stuct
191 * since we want to cast this in a Storage32 pointer */
194 * Reference count of this object
199 * Ancestor storage (top level)
201 StorageImpl
* ancestorStorage
;
204 * Index of the property for the root of
207 ULONG rootPropertySetIndex
;
210 * virtual Destructor method.
212 void (*v_destructor
)(StorageBaseImpl
*);
217 * Prototypes for the methods of the Storage32BaseImpl class.
219 HRESULT WINAPI
StorageBaseImpl_QueryInterface(
224 ULONG WINAPI
StorageBaseImpl_AddRef(
227 ULONG WINAPI
StorageBaseImpl_Release(
230 HRESULT WINAPI
StorageBaseImpl_OpenStream(
232 const OLECHAR
* pwcsName
, /* [string][in] */
233 void* reserved1
, /* [unique][in] */
234 DWORD grfMode
, /* [in] */
235 DWORD reserved2
, /* [in] */
236 IStream
** ppstm
); /* [out] */
238 HRESULT WINAPI
StorageBaseImpl_OpenStorage(
240 const OLECHAR
* pwcsName
, /* [string][unique][in] */
241 IStorage
* pstgPriority
, /* [unique][in] */
242 DWORD grfMode
, /* [in] */
243 SNB snbExclude
, /* [unique][in] */
244 DWORD reserved
, /* [in] */
245 IStorage
** ppstg
); /* [out] */
247 HRESULT WINAPI
StorageBaseImpl_EnumElements(
249 DWORD reserved1
, /* [in] */
250 void* reserved2
, /* [size_is][unique][in] */
251 DWORD reserved3
, /* [in] */
252 IEnumSTATSTG
** ppenum
); /* [out] */
254 HRESULT WINAPI
StorageBaseImpl_Stat(
256 STATSTG
* pstatstg
, /* [out] */
257 DWORD grfStatFlag
); /* [in] */
259 HRESULT WINAPI
StorageBaseImpl_RenameElement(
261 const OLECHAR
* pwcsOldName
, /* [string][in] */
262 const OLECHAR
* pwcsNewName
); /* [string][in] */
264 HRESULT WINAPI
StorageBaseImpl_CreateStream(
266 const OLECHAR
* pwcsName
, /* [string][in] */
267 DWORD grfMode
, /* [in] */
268 DWORD reserved1
, /* [in] */
269 DWORD reserved2
, /* [in] */
270 IStream
** ppstm
); /* [out] */
272 HRESULT WINAPI
StorageBaseImpl_SetClass(
274 REFCLSID clsid
); /* [in] */
276 /****************************************************************************
277 * Storage32Impl definitions.
279 * This implementation of the IStorage32 interface represents a root
280 * storage. Basically, a document file.
284 ICOM_VFIELD(IStorage
); /* Needs to be the first item in the stuct
285 * since we want to cast this in a Storage32 pointer */
288 * Declare the member of the Storage32BaseImpl class to allow
289 * casting as a Storage32BaseImpl
292 struct StorageImpl
* ancestorStorage
;
293 ULONG rootPropertySetIndex
;
294 void (*v_destructor
)(struct StorageImpl
*);
297 * The following data members are specific to the Storage32Impl
300 HANDLE hFile
; /* Physical support for the Docfile */
301 LPOLESTR pwcsName
; /* Full path of the document file */
306 WORD bigBlockSizeBits
;
307 WORD smallBlockSizeBits
;
309 ULONG smallBlockSize
;
310 ULONG bigBlockDepotCount
;
311 ULONG rootStartBlock
;
312 ULONG smallBlockDepotStart
;
313 ULONG extBigBlockDepotStart
;
314 ULONG extBigBlockDepotCount
;
315 ULONG bigBlockDepotStart
[COUNT_BBDEPOTINHEADER
];
317 ULONG blockDepotCached
[NUM_BLOCKS_PER_DEPOT_BLOCK
];
318 ULONG indexBlockDepotCached
;
322 * Abstraction of the big block chains for the chains of the header.
324 BlockChainStream
* rootBlockChain
;
325 BlockChainStream
* smallBlockDepotChain
;
326 BlockChainStream
* smallBlockRootChain
;
329 * Pointer to the big block file abstraction
331 BigBlockFile
* bigBlockFile
;
335 * Method declaration for the Storage32Impl class
338 HRESULT WINAPI
StorageImpl_CreateStorage(
340 const OLECHAR
* pwcsName
, /* [string][in] */
341 DWORD grfMode
, /* [in] */
342 DWORD dwStgFmt
, /* [in] */
343 DWORD reserved2
, /* [in] */
344 IStorage
** ppstg
); /* [out] */
346 HRESULT WINAPI
StorageImpl_CopyTo(
348 DWORD ciidExclude
, /* [in] */
349 const IID
* rgiidExclude
, /* [size_is][unique][in] */
350 SNB snbExclude
, /* [unique][in] */
351 IStorage
* pstgDest
); /* [unique][in] */
353 HRESULT WINAPI
StorageImpl_MoveElementTo(
355 const OLECHAR
* pwcsName
, /* [string][in] */
356 IStorage
* pstgDest
, /* [unique][in] */
357 const OLECHAR
* pwcsNewName
, /* [string][in] */
358 DWORD grfFlags
); /* [in] */
360 HRESULT WINAPI
StorageImpl_Commit(
362 DWORD grfCommitFlags
); /* [in] */
364 HRESULT WINAPI
StorageImpl_Revert(
367 HRESULT WINAPI
StorageImpl_DestroyElement(
369 const OLECHAR
* pwcsName
); /* [string][in] */
371 HRESULT WINAPI
StorageImpl_SetElementTimes(
373 const OLECHAR
* pwcsName
, /* [string][in] */
374 const FILETIME
* pctime
, /* [in] */
375 const FILETIME
* patime
, /* [in] */
376 const FILETIME
* pmtime
); /* [in] */
378 HRESULT WINAPI
StorageImpl_SetStateBits(
380 DWORD grfStateBits
, /* [in] */
381 DWORD grfMask
); /* [in] */
383 HRESULT WINAPI
StorageImpl_Stat(IStorage
* iface
,
384 STATSTG
* pstatstg
, /* [out] */
385 DWORD grfStatFlag
); /* [in] */
387 void StorageImpl_Destroy(
390 HRESULT
StorageImpl_Construct(
399 BOOL
StorageImpl_ReadBigBlock(
404 BOOL
StorageImpl_WriteBigBlock(
409 void* StorageImpl_GetROBigBlock(
413 void* StorageImpl_GetBigBlock(
417 void StorageImpl_ReleaseBigBlock(
421 ULONG
StorageImpl_GetNextFreeBigBlock(
424 void StorageImpl_FreeBigBlock(
428 ULONG
StorageImpl_GetNextBlockInChain(
432 void StorageImpl_SetNextBlockInChain(
437 HRESULT
StorageImpl_LoadFileHeader(
440 void StorageImpl_SaveFileHeader(
443 BOOL
StorageImpl_ReadProperty(
446 StgProperty
* buffer
);
448 BOOL
StorageImpl_WriteProperty(
451 StgProperty
* buffer
);
453 BlockChainStream
* Storage32Impl_SmallBlocksToBigBlocks(
455 SmallBlockChainStream
** ppsbChain
);
457 ULONG
Storage32Impl_GetNextExtendedBlock(StorageImpl
* This
,
460 void Storage32Impl_AddBlockDepot(StorageImpl
* This
,
463 ULONG
Storage32Impl_AddExtBlockDepot(StorageImpl
* This
);
465 ULONG
Storage32Impl_GetExtDepotBlock(StorageImpl
* This
,
468 void Storage32Impl_SetExtDepotBlock(StorageImpl
* This
,
471 /****************************************************************************
472 * Storage32InternalImpl definitions.
474 * Definition of the implementation structure for the IStorage32 interface.
475 * This one implements the IStorage32 interface for storage that are
476 * inside another storage.
478 struct StorageInternalImpl
480 ICOM_VFIELD(IStorage
); /* Needs to be the first item in the stuct
481 * since we want to cast this in a Storage32 pointer */
484 * Declare the member of the Storage32BaseImpl class to allow
485 * casting as a Storage32BaseImpl
488 struct StorageImpl
* ancestorStorage
;
489 ULONG rootPropertySetIndex
;
490 void (*v_destructor
)(struct StorageInternalImpl
*);
493 * There is no specific data for this class.
498 * Method definitions for the Storage32InternalImpl class.
500 StorageInternalImpl
* StorageInternalImpl_Construct(
501 StorageImpl
* ancestorStorage
,
502 ULONG rootTropertyIndex
);
504 void StorageInternalImpl_Destroy(
505 StorageInternalImpl
* This
);
507 HRESULT WINAPI
StorageInternalImpl_Commit(
509 DWORD grfCommitFlags
); /* [in] */
511 HRESULT WINAPI
StorageInternalImpl_Revert(
515 /****************************************************************************
516 * IEnumSTATSTGImpl definitions.
518 * Definition of the implementation structure for the IEnumSTATSTGImpl interface.
519 * This class allows iterating through the content of a storage and to find
520 * specific items inside it.
522 struct IEnumSTATSTGImpl
524 ICOM_VFIELD(IEnumSTATSTG
); /* Needs to be the first item in the stuct
525 * since we want to cast this in a IEnumSTATSTG pointer */
527 ULONG ref
; /* Reference count */
528 StorageImpl
* parentStorage
; /* Reference to the parent storage */
529 ULONG firstPropertyNode
; /* Index of the root of the storage to enumerate */
532 * The current implementation of the IEnumSTATSTGImpl class uses a stack
533 * to walk the property sets to get the content of a storage. This stack
534 * is implemented by the following 3 data members
540 #define ENUMSTATSGT_SIZE_INCREMENT 10
544 * Method definitions for the IEnumSTATSTGImpl class.
546 HRESULT WINAPI
IEnumSTATSTGImpl_QueryInterface(
551 ULONG WINAPI
IEnumSTATSTGImpl_AddRef(
552 IEnumSTATSTG
* iface
);
554 ULONG WINAPI
IEnumSTATSTGImpl_Release(
555 IEnumSTATSTG
* iface
);
557 HRESULT WINAPI
IEnumSTATSTGImpl_Next(
561 ULONG
* pceltFetched
);
563 HRESULT WINAPI
IEnumSTATSTGImpl_Skip(
567 HRESULT WINAPI
IEnumSTATSTGImpl_Reset(
568 IEnumSTATSTG
* iface
);
570 HRESULT WINAPI
IEnumSTATSTGImpl_Clone(
572 IEnumSTATSTG
** ppenum
);
574 IEnumSTATSTGImpl
* IEnumSTATSTGImpl_Construct(
576 ULONG firstPropertyNode
);
578 void IEnumSTATSTGImpl_Destroy(
579 IEnumSTATSTGImpl
* This
);
581 void IEnumSTATSTGImpl_PushSearchNode(
582 IEnumSTATSTGImpl
* This
,
585 ULONG
IEnumSTATSTGImpl_PopSearchNode(
586 IEnumSTATSTGImpl
* This
,
589 ULONG
IEnumSTATSTGImpl_FindProperty(
590 IEnumSTATSTGImpl
* This
,
591 const OLECHAR
* lpszPropName
,
592 StgProperty
* buffer
);
594 INT
IEnumSTATSTGImpl_FindParentProperty(
595 IEnumSTATSTGImpl
*This
,
597 StgProperty
*currentProperty
,
601 /****************************************************************************
602 * StgStreamImpl definitions.
604 * This class imlements the IStream32 inteface and represents a stream
605 * located inside a storage object.
609 ICOM_VFIELD(IStream
); /* Needs to be the first item in the stuct
610 * since we want to cast this in a IStream pointer */
618 * Storage that is the parent(owner) of the stream
620 StorageBaseImpl
* parentStorage
;
623 * Access mode of this stream.
628 * Index of the property that owns (points to) this stream.
633 * Helper variable that contains the size of the stream
635 ULARGE_INTEGER streamSize
;
638 * This is the current position of the cursor in the stream
640 ULARGE_INTEGER currentPosition
;
643 * The information in the stream is represented by a chain of small blocks
644 * or a chain of large blocks. Depending on the case, one of the two
645 * following variabled points to that information.
647 BlockChainStream
* bigBlockChain
;
648 SmallBlockChainStream
* smallBlockChain
;
652 * Method definition for the StgStreamImpl class.
654 StgStreamImpl
* StgStreamImpl_Construct(
655 StorageBaseImpl
* parentStorage
,
657 ULONG ownerProperty
);
659 void StgStreamImpl_Destroy(
660 StgStreamImpl
* This
);
662 void StgStreamImpl_OpenBlockChain(
663 StgStreamImpl
* This
);
665 HRESULT WINAPI
StgStreamImpl_QueryInterface(
667 REFIID riid
, /* [in] */
668 void** ppvObject
); /* [iid_is][out] */
670 ULONG WINAPI
StgStreamImpl_AddRef(
673 ULONG WINAPI
StgStreamImpl_Release(
676 HRESULT WINAPI
StgStreamImpl_Read(
678 void* pv
, /* [length_is][size_is][out] */
680 ULONG
* pcbRead
); /* [out] */
682 HRESULT WINAPI
StgStreamImpl_Write(
684 const void* pv
, /* [size_is][in] */
686 ULONG
* pcbWritten
); /* [out] */
688 HRESULT WINAPI
StgStreamImpl_Seek(
690 LARGE_INTEGER dlibMove
, /* [in] */
691 DWORD dwOrigin
, /* [in] */
692 ULARGE_INTEGER
* plibNewPosition
); /* [out] */
694 HRESULT WINAPI
StgStreamImpl_SetSize(
696 ULARGE_INTEGER libNewSize
); /* [in] */
698 HRESULT WINAPI
StgStreamImpl_CopyTo(
700 IStream
* pstm
, /* [unique][in] */
701 ULARGE_INTEGER cb
, /* [in] */
702 ULARGE_INTEGER
* pcbRead
, /* [out] */
703 ULARGE_INTEGER
* pcbWritten
); /* [out] */
705 HRESULT WINAPI
StgStreamImpl_Commit(
707 DWORD grfCommitFlags
); /* [in] */
709 HRESULT WINAPI
StgStreamImpl_Revert(
712 HRESULT WINAPI
StgStreamImpl_LockRegion(
714 ULARGE_INTEGER libOffset
, /* [in] */
715 ULARGE_INTEGER cb
, /* [in] */
716 DWORD dwLockType
); /* [in] */
718 HRESULT WINAPI
StgStreamImpl_UnlockRegion(
720 ULARGE_INTEGER libOffset
, /* [in] */
721 ULARGE_INTEGER cb
, /* [in] */
722 DWORD dwLockType
); /* [in] */
724 HRESULT WINAPI
StgStreamImpl_Stat(
726 STATSTG
* pstatstg
, /* [out] */
727 DWORD grfStatFlag
); /* [in] */
729 HRESULT WINAPI
StgStreamImpl_Clone(
731 IStream
** ppstm
); /* [out] */
734 /********************************************************************************
735 * The StorageUtl_ functions are miscelaneous utility functions. Most of which are
736 * abstractions used to read values from file buffers without having to worry
739 void StorageUtl_ReadWord(void* buffer
, ULONG offset
, WORD
* value
);
740 void StorageUtl_WriteWord(void* buffer
, ULONG offset
, WORD value
);
741 void StorageUtl_ReadDWord(void* buffer
, ULONG offset
, DWORD
* value
);
742 void StorageUtl_WriteDWord(void* buffer
, ULONG offset
, DWORD value
);
743 void StorageUtl_ReadGUID(void* buffer
, ULONG offset
, GUID
* value
);
744 void StorageUtl_WriteGUID(void* buffer
, ULONG offset
, GUID
* value
);
745 void StorageUtl_CopyPropertyToSTATSTG(STATSTG
* destination
,
749 /****************************************************************************
750 * BlockChainStream definitions.
752 * The BlockChainStream class is a utility class that is used to create an
753 * abstraction of the big block chains in the storage file.
755 struct BlockChainStream
757 StorageImpl
* parentStorage
;
758 ULONG
* headOfStreamPlaceHolder
;
759 ULONG ownerPropertyIndex
;
760 ULONG lastBlockNoInSequence
;
761 ULONG lastBlockNoInSequenceIndex
;
767 * Methods for the BlockChainStream class.
769 BlockChainStream
* BlockChainStream_Construct(
770 StorageImpl
* parentStorage
,
771 ULONG
* headOfStreamPlaceHolder
,
772 ULONG propertyIndex
);
774 void BlockChainStream_Destroy(
775 BlockChainStream
* This
);
777 ULONG
BlockChainStream_GetHeadOfChain(
778 BlockChainStream
* This
);
780 BOOL
BlockChainStream_ReadAt(
781 BlockChainStream
* This
,
782 ULARGE_INTEGER offset
,
787 BOOL
BlockChainStream_WriteAt(
788 BlockChainStream
* This
,
789 ULARGE_INTEGER offset
,
792 ULONG
* bytesWritten
);
794 BOOL
BlockChainStream_SetSize(
795 BlockChainStream
* This
,
796 ULARGE_INTEGER newSize
);
798 ULARGE_INTEGER
BlockChainStream_GetSize(
799 BlockChainStream
* This
);
801 ULONG
BlockChainStream_GetCount(
802 BlockChainStream
* This
);
804 /****************************************************************************
805 * SmallBlockChainStream definitions.
807 * The SmallBlockChainStream class is a utility class that is used to create an
808 * abstraction of the small block chains in the storage file.
810 struct SmallBlockChainStream
812 StorageImpl
* parentStorage
;
813 ULONG ownerPropertyIndex
;
817 * Methods of the SmallBlockChainStream class.
819 SmallBlockChainStream
* SmallBlockChainStream_Construct(
820 StorageImpl
* parentStorage
,
821 ULONG propertyIndex
);
823 void SmallBlockChainStream_Destroy(
824 SmallBlockChainStream
* This
);
826 ULONG
SmallBlockChainStream_GetHeadOfChain(
827 SmallBlockChainStream
* This
);
829 ULONG
SmallBlockChainStream_GetNextBlockInChain(
830 SmallBlockChainStream
* This
,
833 void SmallBlockChainStream_SetNextBlockInChain(
834 SmallBlockChainStream
* This
,
838 void SmallBlockChainStream_FreeBlock(
839 SmallBlockChainStream
* This
,
842 ULONG
SmallBlockChainStream_GetNextFreeBlock(
843 SmallBlockChainStream
* This
);
845 BOOL
SmallBlockChainStream_ReadAt(
846 SmallBlockChainStream
* This
,
847 ULARGE_INTEGER offset
,
852 BOOL
SmallBlockChainStream_WriteAt(
853 SmallBlockChainStream
* This
,
854 ULARGE_INTEGER offset
,
857 ULONG
* bytesWritten
);
859 BOOL
SmallBlockChainStream_SetSize(
860 SmallBlockChainStream
* This
,
861 ULARGE_INTEGER newSize
);
863 ULARGE_INTEGER
SmallBlockChainStream_GetSize(
864 SmallBlockChainStream
* This
);
866 ULONG
SmallBlockChainStream_GetCount(
867 SmallBlockChainStream
* This
);
870 #endif /* __STORAGE32_H__ */