1 files changed, 213 insertions, 213 deletions
diff --git a/src/stable/myriad.h b/src/stable/myriad.h
index 6b1db41..4bfd88e 100644
--- a/src/stable/myriad.h
+++ b/src/stable/myriad.h
@@ -18,219 +18,219 @@
 namespace Bu
 {
-        class Stream;
+    class Stream;
-        class MyriadStream;
+    class MyriadStream;
-        subExceptionDeclBegin( MyriadException )
+    subExceptionDeclBegin( MyriadException )
-                enum
+        enum
-                {
+        {
-                        emptyStream,
+            emptyStream,
-                        invalidFormat,
+            invalidFormat,
-                        badVersion,
+            badVersion,
-                        invalidWordSize,
+            invalidWordSize,
-                        noSuchStream,
+            noSuchStream,
-                        streamExists,
+            streamExists,
-                        invalidStreamId,
+            invalidStreamId,
-                        protectedStream
+            protectedStream
-                };
+        };
-        subExceptionDeclEnd();
+    subExceptionDeclEnd();
-        /**
+    /**
-         * Myriad block-allocated stream multiplexing system.  This is a system for
+     * Myriad block-allocated stream multiplexing system.  This is a system for
-         * creating streams that contain other streams in a flexible and lightweight
+     * creating streams that contain other streams in a flexible and lightweight
-         * manner.  Basically, you can create a file (or any other stream) that can
+     * manner.  Basically, you can create a file (or any other stream) that can
-         * store any number of flexible, growing streams.  The streams within the
+     * store any number of flexible, growing streams.  The streams within the
-         * Myriad stream are automatically numbered, not named.  This works more
+     * Myriad stream are automatically numbered, not named.  This works more
-         * or less like a filesystem, but without the extra layer for managing
+     * or less like a filesystem, but without the extra layer for managing
-         * file and directory links.  This would actually be very easy to add
+     * file and directory links.  This would actually be very easy to add
-         * on top of Myriad, but is not required.
+     * on top of Myriad, but is not required.
-         *
+     *
-         * Header format is as follows:
+     * Header format is as follows:
-         *
+     *
-         * MMMMvBssssSSSS*
+     * MMMMvBssssSSSS*
-         * M = Magic number (0AD3FA84)
+     * M = Magic number (0AD3FA84)
-         * v = version number
+     * v = version number
-         * B = Bits per int
+     * B = Bits per int
-         * s = Blocksize in bytes
+     * s = Blocksize in bytes
-         * S = Number of Streams
+     * S = Number of Streams
-         * 
+     * 
-         * The * represents the Stream headers, one per stream, as follows:
+     * The * represents the Stream headers, one per stream, as follows:
-         * IIIIssss$
+     * IIIIssss$
-         * I = Id number of the stream
+     * I = Id number of the stream
-         * s = size of stream in bytes
+     * s = size of stream in bytes
-         *
+     *
-         * The $ represents the Block headers, one per used block, as  follows:
+     * The $ represents the Block headers, one per used block, as  follows:
-         * IIII
+     * IIII
-         * I = Index of the block
+     * I = Index of the block
-         *
+     *
-         * The stream/block data is interleaved in the header, so all blocks stored
+     * The stream/block data is interleaved in the header, so all blocks stored
-         * with one stream are together.  The block headers are in order, and the
+     * with one stream are together.  The block headers are in order, and the
-         * data in them is required to be "solid" you cannot fill partial blocks
+     * data in them is required to be "solid" you cannot fill partial blocks
-         * mid-way through a stream.
+     * mid-way through a stream.
-         *
+     *
-         * The initial block starts with the nids header, and is both the zero block
+     * The initial block starts with the nids header, and is both the zero block
-         * and the zero stream.  For now, the minimum block size is the size needed
+     * and the zero stream.  For now, the minimum block size is the size needed
-         * to store the base header, the zero stream header, and the first two
+     * to store the base header, the zero stream header, and the first two
-         * blocks of the zero stream, so 30 bytes.  Since it's reccomended to use
+     * blocks of the zero stream, so 30 bytes.  Since it's reccomended to use
-         * a size that will fit evenly into filesystem blocks, then a size of 32 is
+     * a size that will fit evenly into filesystem blocks, then a size of 32 is
-         * probably the smallest reccomended size because all powers of two equal
+     * probably the smallest reccomended size because all powers of two equal
-         * to or greater than 32 are evenly divisible by 32.
+     * to or greater than 32 are evenly divisible by 32.
-         *
+     *
-         * I have had a thought that if the block size were smaller than 42 bytes
+     * I have had a thought that if the block size were smaller than 42 bytes
-         * the header would consume the first N blocks where N * block size is
+     * the header would consume the first N blocks where N * block size is
-         * enough space to house the initial header, the first stream header, and
+     * enough space to house the initial header, the first stream header, and
-         * the first N block headers.  This, of course, causes you to hit an
+     * the first N block headers.  This, of course, causes you to hit an
-         * infinite header if the block size is small enough.
+     * infinite header if the block size is small enough.
-         */
+     */
-        class Myriad
+    class Myriad
-        {
+    {
-                friend class MyriadStream;
+        friend class MyriadStream;
-        public:
+    public:
-                /**
+        /**
-                 * Create a Myriad object that uses the given stream to store data.
+         * Create a Myriad object that uses the given stream to store data.
-                 * This stream must be random access.  The block size and preallocate
+         * This stream must be random access.  The block size and preallocate
-                 * values passed in are values that will be used if the given stream
+         * values passed in are values that will be used if the given stream
-                 * is empty.  In that case the stream will be "formatted" for myriad
+         * is empty.  In that case the stream will be "formatted" for myriad
-                 * with the specified block size.  If there is already a viable Myriad
+         * with the specified block size.  If there is already a viable Myriad
-                 * format present in the stream, then the blocksize and preallocate
+         * format present in the stream, then the blocksize and preallocate
-                 * values will be ignored and the values from the stream will be used
+         * values will be ignored and the values from the stream will be used
-                 * instead.  If the stream doesn't appear to be Myriad formatted an
+         * instead.  If the stream doesn't appear to be Myriad formatted an
-                 * exception will be thrown.
+         * exception will be thrown.
-                 */
+         */
-                Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
+        Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
-                virtual ~Myriad();
+        virtual ~Myriad();
-                /**
+        /**
-                 * Destroy whatever data may be in the base stream and create a new
+         * Destroy whatever data may be in the base stream and create a new
-                 * Myriad system there with the given blocksize.  Use this with care,
+         * Myriad system there with the given blocksize.  Use this with care,
-                 * it will destroy anything that was already in the stream, and
+         * it will destroy anything that was already in the stream, and
-                 * generally, should not ever have to be used.
+         * generally, should not ever have to be used.
-                 */
+         */
-                void initialize( int iBlockSize, int iPreAllocate=1 );
+        void initialize( int iBlockSize, int iPreAllocate=1 );
-                /**
+        /**
-                 * Create a new stream within the Myriad system.  The ID of the new
+         * Create a new stream within the Myriad system.  The ID of the new
-                 * stream is returned.
+         * stream is returned.
-                 */
+         */
-                int createStream( int iPreAllocate=1 );
+        int createStream( int iPreAllocate=1 );
-                /**
+        /**
-                 * Create a new stream within the Myriad system with a given id.  The
+         * Create a new stream within the Myriad system with a given id.  The
-                 * id that you provide will be the new id of the stream unless it's
+         * id that you provide will be the new id of the stream unless it's
-                 * already used, in which case an error is thrown.  This is primarilly
+         * already used, in which case an error is thrown.  This is primarilly
-                 * useful when copying an old Myriad file into a new one.
+         * useful when copying an old Myriad file into a new one.
-                 */
+         */
-                int createStreamWithId( int iId, int iPreAllocate=1 );
+        int createStreamWithId( int iId, int iPreAllocate=1 );
-                /**
+        /**
-                 * Delete a stream that's already within the Myriad.
+         * Delete a stream that's already within the Myriad.
-                 */
+         */
-                void deleteStream( int iId );
+        void deleteStream( int iId );
-                /**
+        /**
-                 * Return a new Stream object assosiated with the given stream ID.
+         * Return a new Stream object assosiated with the given stream ID.
-                 */
+         */
-                MyriadStream openStream( int iId );
+        MyriadStream openStream( int iId );
-                Bu::Array<int> getStreamIds();
+        Bu::Array<int> getStreamIds();
-                int getStreamSize( int iId );
+        int getStreamSize( int iId );
-                bool hasStream( int iId );
+        bool hasStream( int iId );
-                int getNumStreams();
+        int getNumStreams();
-                int getBlockSize();
+        int getBlockSize();
-                int getNumBlocks();
+        int getNumBlocks();
-                int getNumUsedBlocks();
+        int getNumUsedBlocks();
-                Bu::size getTotalUsedBytes();
+        Bu::size getTotalUsedBytes();
-                Bu::size getTotalUnusedBytes();
+        Bu::size getTotalUnusedBytes();
-                Bu::size getTotalUnusedBytes( int iFakeBlockSize );
+        Bu::size getTotalUnusedBytes( int iFakeBlockSize );
-                /**
+        /**
-                 * Syncronize the header data, etc. with the storage stream.  It's not
+         * Syncronize the header data, etc. with the storage stream.  It's not
-                 * a bad idea to call this periodically.
+         * a bad idea to call this periodically.
-                 */
+         */
-                void sync();
+        void sync();
-                /**
+        /**
-                 * Read the first few bytes from the given stream and return true/false
+         * Read the first few bytes from the given stream and return true/false
-                 * depending on weather or not it's a Myriad stream.  This will throw
+         * depending on weather or not it's a Myriad stream.  This will throw
-                 * an exception if the stream is empty, or is not random access.
+         * an exception if the stream is empty, or is not random access.
-                 */
+         */
-                static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
+        static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
-                
+        
-                /**
+        /**
-                 * Read the first few bytes from the given stream and return true/false
+         * Read the first few bytes from the given stream and return true/false
-                 * depending on weather or not it's a Myriad stream.  This will throw
+         * depending on weather or not it's a Myriad stream.  This will throw
-                 * an exception if the stream is empty, or is not random access.
+         * an exception if the stream is empty, or is not random access.
-                 */
+         */
-                static bool isMyriad( Bu::Stream &sStore );
+        static bool isMyriad( Bu::Stream &sStore );
-                const Bu::BitString getBlocksUsed() const;
+        const Bu::BitString getBlocksUsed() const;
-        private:
+    private:
-                /**
+        /**
-                 * Initialize this object based on the data already in the assosiated
+         * Initialize this object based on the data already in the assosiated
-                 * stream.  This will be called automatically for you if you forget,
+         * stream.  This will be called automatically for you if you forget,
-                 * but if you want to pre-initialize for some reason, just call this
+         * but if you want to pre-initialize for some reason, just call this
-                 * once before you actually start doing anything with your Myriad.
+         * once before you actually start doing anything with your Myriad.
-                 */
+         */
-                void initialize();
+        void initialize();
-                enum
+        enum
-                {
+        {
-                        blockUnused     =       0xFFFFFFFFUL
+            blockUnused =   0xFFFFFFFFUL
-                };
+        };
-                
+        
-                typedef Bu::Array<int> BlockArray;
+        typedef Bu::Array<int> BlockArray;
-                class Stream
+        class Stream
-                {
+        {
-                public:
+        public:
-                        int iId;
+            int iId;
-                        int iSize;
+            int iSize;
-                        BlockArray aBlocks;
+            BlockArray aBlocks;
-                };
+        };
-                typedef Bu::Array<Stream *> StreamArray;
+        typedef Bu::Array<Stream *> StreamArray;
-                class Block
+        class Block
-                {
+        {
-                public:
+        public:
-                        char *pData;
+            char *pData;
-                        bool bChanged;
+            bool bChanged;
-                        int iBlockIndex;
+            int iBlockIndex;
-                };
+        };
-                void updateHeader();
+        void updateHeader();
-                int findEmptyBlock();
+        int findEmptyBlock();
-                /**
+        /**
-                 *@todo Change this to use a binary search, it's nicer.
+         *@todo Change this to use a binary search, it's nicer.
-                 */
+         */
-                Stream *findStream( int iId );
+        Stream *findStream( int iId );
-                Block *getBlock( int iBlock );
+        Block *getBlock( int iBlock );
-                void releaseBlock( Block *pBlock );
+        void releaseBlock( Block *pBlock );
-                void syncBlock( Block *pBlock );
+        void syncBlock( Block *pBlock );
-                int streamAddBlock( Stream *pStream );
+        int streamAddBlock( Stream *pStream );
-                void setStreamSize( Stream *pStream, long iSize );
+        void setStreamSize( Stream *pStream, long iSize );
-                void headerChanged();
+        void headerChanged();
-        private:
+    private:
-                Bu::Stream &sStore;
+        Bu::Stream &sStore;
-                int iBlockSize;
+        int iBlockSize;
-                int iBlocks;
+        int iBlocks;
-                int iUsed;
+        int iUsed;
-                typedef Bu::List<int> IndexList;
+        typedef Bu::List<int> IndexList;
-                IndexList lFreeBlocks;
+        IndexList lFreeBlocks;
-//              Bu::BitString bsBlockUsed;
+//      Bu::BitString bsBlockUsed;
-                StreamArray aStreams;
+        StreamArray aStreams;
-                typedef Bu::Hash<int, Block *> BlockHash;
+        typedef Bu::Hash<int, Block *> BlockHash;
-                BlockHash hActiveBlocks;
+        BlockHash hActiveBlocks;
-                bool bHeaderChanged;
+        bool bHeaderChanged;
-                Bu::Mutex mHeader;
+        Bu::Mutex mHeader;
-                Bu::Mutex mActiveBlocks;
+        Bu::Mutex mActiveBlocks;
-        };
+    };
 };
 #endif

diff --git a/src/stable/myriad.h b/src/stable/myriad.h index 6b1db41..4bfd88e 100644 --- a/src/stable/myriad.h +++ b/src/stable/myriad.h
@@ -18,219 +18,219 @@
18		18
19	namespace Bu	19	namespace Bu
20	{	20	{
21	class Stream;	21	class Stream;
22	class MyriadStream;	22	class MyriadStream;
23		23
24	subExceptionDeclBegin( MyriadException )	24	subExceptionDeclBegin( MyriadException )
25	enum	25	enum
26	{	26	{
27	emptyStream,	27	emptyStream,
28	invalidFormat,	28	invalidFormat,
29	badVersion,	29	badVersion,
30	invalidWordSize,	30	invalidWordSize,
31	noSuchStream,	31	noSuchStream,
32	streamExists,	32	streamExists,
33	invalidStreamId,	33	invalidStreamId,
34	protectedStream	34	protectedStream
35	};	35	};
36	subExceptionDeclEnd();	36	subExceptionDeclEnd();
37		37
38	/**	38	/**
39	* Myriad block-allocated stream multiplexing system. This is a system for	39	* Myriad block-allocated stream multiplexing system. This is a system for
40	* creating streams that contain other streams in a flexible and lightweight	40	* creating streams that contain other streams in a flexible and lightweight
41	* manner. Basically, you can create a file (or any other stream) that can	41	* manner. Basically, you can create a file (or any other stream) that can
42	* store any number of flexible, growing streams. The streams within the	42	* store any number of flexible, growing streams. The streams within the
43	* Myriad stream are automatically numbered, not named. This works more	43	* Myriad stream are automatically numbered, not named. This works more
44	* or less like a filesystem, but without the extra layer for managing	44	* or less like a filesystem, but without the extra layer for managing
45	* file and directory links. This would actually be very easy to add	45	* file and directory links. This would actually be very easy to add
46	* on top of Myriad, but is not required.	46	* on top of Myriad, but is not required.
47	*	47	*
48	* Header format is as follows:	48	* Header format is as follows:
49	*	49	*
50	* MMMMvBssssSSSS*	50	* MMMMvBssssSSSS*
51	* M = Magic number (0AD3FA84)	51	* M = Magic number (0AD3FA84)
52	* v = version number	52	* v = version number
53	* B = Bits per int	53	* B = Bits per int
54	* s = Blocksize in bytes	54	* s = Blocksize in bytes
55	* S = Number of Streams	55	* S = Number of Streams
56	*	56	*
57	* The * represents the Stream headers, one per stream, as follows:	57	* The * represents the Stream headers, one per stream, as follows:
58	* IIIIssss$	58	* IIIIssss$
59	* I = Id number of the stream	59	* I = Id number of the stream
60	* s = size of stream in bytes	60	* s = size of stream in bytes
61	*	61	*
62	* The $ represents the Block headers, one per used block, as follows:	62	* The $ represents the Block headers, one per used block, as follows:
63	* IIII	63	* IIII
64	* I = Index of the block	64	* I = Index of the block
65	*	65	*
66	* The stream/block data is interleaved in the header, so all blocks stored	66	* The stream/block data is interleaved in the header, so all blocks stored
67	* with one stream are together. The block headers are in order, and the	67	* with one stream are together. The block headers are in order, and the
68	* data in them is required to be "solid" you cannot fill partial blocks	68	* data in them is required to be "solid" you cannot fill partial blocks
69	* mid-way through a stream.	69	* mid-way through a stream.
70	*	70	*
71	* The initial block starts with the nids header, and is both the zero block	71	* The initial block starts with the nids header, and is both the zero block
72	* and the zero stream. For now, the minimum block size is the size needed	72	* and the zero stream. For now, the minimum block size is the size needed
73	* to store the base header, the zero stream header, and the first two	73	* to store the base header, the zero stream header, and the first two
74	* blocks of the zero stream, so 30 bytes. Since it's reccomended to use	74	* blocks of the zero stream, so 30 bytes. Since it's reccomended to use
75	* a size that will fit evenly into filesystem blocks, then a size of 32 is	75	* a size that will fit evenly into filesystem blocks, then a size of 32 is
76	* probably the smallest reccomended size because all powers of two equal	76	* probably the smallest reccomended size because all powers of two equal
77	* to or greater than 32 are evenly divisible by 32.	77	* to or greater than 32 are evenly divisible by 32.
78	*	78	*
79	* I have had a thought that if the block size were smaller than 42 bytes	79	* I have had a thought that if the block size were smaller than 42 bytes
80	* the header would consume the first N blocks where N * block size is	80	* the header would consume the first N blocks where N * block size is
81	* enough space to house the initial header, the first stream header, and	81	* enough space to house the initial header, the first stream header, and
82	* the first N block headers. This, of course, causes you to hit an	82	* the first N block headers. This, of course, causes you to hit an
83	* infinite header if the block size is small enough.	83	* infinite header if the block size is small enough.
84	*/	84	*/
85	class Myriad	85	class Myriad
86	{	86	{
87	friend class MyriadStream;	87	friend class MyriadStream;
88	public:	88	public:
89	/**	89	/**
90	* Create a Myriad object that uses the given stream to store data.	90	* Create a Myriad object that uses the given stream to store data.
91	* This stream must be random access. The block size and preallocate	91	* This stream must be random access. The block size and preallocate
92	* values passed in are values that will be used if the given stream	92	* values passed in are values that will be used if the given stream
93	* is empty. In that case the stream will be "formatted" for myriad	93	* is empty. In that case the stream will be "formatted" for myriad
94	* with the specified block size. If there is already a viable Myriad	94	* with the specified block size. If there is already a viable Myriad
95	* format present in the stream, then the blocksize and preallocate	95	* format present in the stream, then the blocksize and preallocate
96	* values will be ignored and the values from the stream will be used	96	* values will be ignored and the values from the stream will be used
97	* instead. If the stream doesn't appear to be Myriad formatted an	97	* instead. If the stream doesn't appear to be Myriad formatted an
98	* exception will be thrown.	98	* exception will be thrown.
99	*/	99	*/
100	Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );	100	Myriad( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 );
101	virtual ~Myriad();	101	virtual ~Myriad();
102		102
103	/**	103	/**
104	* Destroy whatever data may be in the base stream and create a new	104	* Destroy whatever data may be in the base stream and create a new
105	* Myriad system there with the given blocksize. Use this with care,	105	* Myriad system there with the given blocksize. Use this with care,
106	* it will destroy anything that was already in the stream, and	106	* it will destroy anything that was already in the stream, and
107	* generally, should not ever have to be used.	107	* generally, should not ever have to be used.
108	*/	108	*/
109	void initialize( int iBlockSize, int iPreAllocate=1 );	109	void initialize( int iBlockSize, int iPreAllocate=1 );
110		110
111	/**	111	/**
112	* Create a new stream within the Myriad system. The ID of the new	112	* Create a new stream within the Myriad system. The ID of the new
113	* stream is returned.	113	* stream is returned.
114	*/	114	*/
115	int createStream( int iPreAllocate=1 );	115	int createStream( int iPreAllocate=1 );
116		116
117	/**	117	/**
118	* Create a new stream within the Myriad system with a given id. The	118	* Create a new stream within the Myriad system with a given id. The
119	* id that you provide will be the new id of the stream unless it's	119	* id that you provide will be the new id of the stream unless it's
120	* already used, in which case an error is thrown. This is primarilly	120	* already used, in which case an error is thrown. This is primarilly
121	* useful when copying an old Myriad file into a new one.	121	* useful when copying an old Myriad file into a new one.
122	*/	122	*/
123	int createStreamWithId( int iId, int iPreAllocate=1 );	123	int createStreamWithId( int iId, int iPreAllocate=1 );
124		124
125	/**	125	/**
126	* Delete a stream that's already within the Myriad.	126	* Delete a stream that's already within the Myriad.
127	*/	127	*/
128	void deleteStream( int iId );	128	void deleteStream( int iId );
129		129
130	/**	130	/**
131	* Return a new Stream object assosiated with the given stream ID.	131	* Return a new Stream object assosiated with the given stream ID.
132	*/	132	*/
133	MyriadStream openStream( int iId );	133	MyriadStream openStream( int iId );
134		134
135	Bu::Array<int> getStreamIds();	135	Bu::Array<int> getStreamIds();
136	int getStreamSize( int iId );	136	int getStreamSize( int iId );
137	bool hasStream( int iId );	137	bool hasStream( int iId );
138		138
139	int getNumStreams();	139	int getNumStreams();
140	int getBlockSize();	140	int getBlockSize();
141	int getNumBlocks();	141	int getNumBlocks();
142	int getNumUsedBlocks();	142	int getNumUsedBlocks();
143	Bu::size getTotalUsedBytes();	143	Bu::size getTotalUsedBytes();
144	Bu::size getTotalUnusedBytes();	144	Bu::size getTotalUnusedBytes();
145	Bu::size getTotalUnusedBytes( int iFakeBlockSize );	145	Bu::size getTotalUnusedBytes( int iFakeBlockSize );
146		146
147	/**	147	/**
148	* Syncronize the header data, etc. with the storage stream. It's not	148	* Syncronize the header data, etc. with the storage stream. It's not
149	* a bad idea to call this periodically.	149	* a bad idea to call this periodically.
150	*/	150	*/
151	void sync();	151	void sync();
152		152
153	/**	153	/**
154	* Read the first few bytes from the given stream and return true/false	154	* Read the first few bytes from the given stream and return true/false
155	* depending on weather or not it's a Myriad stream. This will throw	155	* depending on weather or not it's a Myriad stream. This will throw
156	* an exception if the stream is empty, or is not random access.	156	* an exception if the stream is empty, or is not random access.
157	*/	157	*/
158	static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );	158	static bool isMyriad( Bu::Stream &sStore, uint8_t &uVer );
159		159
160	/**	160	/**
161	* Read the first few bytes from the given stream and return true/false	161	* Read the first few bytes from the given stream and return true/false
162	* depending on weather or not it's a Myriad stream. This will throw	162	* depending on weather or not it's a Myriad stream. This will throw
163	* an exception if the stream is empty, or is not random access.	163	* an exception if the stream is empty, or is not random access.
164	*/	164	*/
165	static bool isMyriad( Bu::Stream &sStore );	165	static bool isMyriad( Bu::Stream &sStore );
166		166
167	const Bu::BitString getBlocksUsed() const;	167	const Bu::BitString getBlocksUsed() const;
168		168
169	private:	169	private:
170	/**	170	/**
171	* Initialize this object based on the data already in the assosiated	171	* Initialize this object based on the data already in the assosiated
172	* stream. This will be called automatically for you if you forget,	172	* stream. This will be called automatically for you if you forget,
173	* but if you want to pre-initialize for some reason, just call this	173	* but if you want to pre-initialize for some reason, just call this
174	* once before you actually start doing anything with your Myriad.	174	* once before you actually start doing anything with your Myriad.
175	*/	175	*/
176	void initialize();	176	void initialize();
177		177
178	enum	178	enum
179	{	179	{
180	blockUnused = 0xFFFFFFFFUL	180	blockUnused = 0xFFFFFFFFUL
181	};	181	};
182		182
183	typedef Bu::Array<int> BlockArray;	183	typedef Bu::Array<int> BlockArray;
184	class Stream	184	class Stream
185	{	185	{
186	public:	186	public:
187	int iId;	187	int iId;
188	int iSize;	188	int iSize;
189	BlockArray aBlocks;	189	BlockArray aBlocks;
190	};	190	};
191	typedef Bu::Array<Stream *> StreamArray;	191	typedef Bu::Array<Stream *> StreamArray;
192		192
193	class Block	193	class Block
194	{	194	{
195	public:	195	public:
196	char *pData;	196	char *pData;
197	bool bChanged;	197	bool bChanged;
198	int iBlockIndex;	198	int iBlockIndex;
199	};	199	};
200		200
201	void updateHeader();	201	void updateHeader();
202	int findEmptyBlock();	202	int findEmptyBlock();
203		203
204	/**	204	/**
205	*@todo Change this to use a binary search, it's nicer.	205	*@todo Change this to use a binary search, it's nicer.
206	*/	206	*/
207	Stream *findStream( int iId );	207	Stream *findStream( int iId );
208		208
209	Block *getBlock( int iBlock );	209	Block *getBlock( int iBlock );
210	void releaseBlock( Block *pBlock );	210	void releaseBlock( Block *pBlock );
211	void syncBlock( Block *pBlock );	211	void syncBlock( Block *pBlock );
212		212
213	int streamAddBlock( Stream *pStream );	213	int streamAddBlock( Stream *pStream );
214	void setStreamSize( Stream *pStream, long iSize );	214	void setStreamSize( Stream *pStream, long iSize );
215		215
216	void headerChanged();	216	void headerChanged();
217		217
218	private:	218	private:
219	Bu::Stream &sStore;	219	Bu::Stream &sStore;
220	int iBlockSize;	220	int iBlockSize;
221	int iBlocks;	221	int iBlocks;
222	int iUsed;	222	int iUsed;
223	typedef Bu::List<int> IndexList;	223	typedef Bu::List<int> IndexList;
224	IndexList lFreeBlocks;	224	IndexList lFreeBlocks;
225	// Bu::BitString bsBlockUsed;	225	// Bu::BitString bsBlockUsed;
226	StreamArray aStreams;	226	StreamArray aStreams;
227	typedef Bu::Hash<int, Block *> BlockHash;	227	typedef Bu::Hash<int, Block *> BlockHash;
228	BlockHash hActiveBlocks;	228	BlockHash hActiveBlocks;
229	bool bHeaderChanged;	229	bool bHeaderChanged;
230		230
231	Bu::Mutex mHeader;	231	Bu::Mutex mHeader;
232	Bu::Mutex mActiveBlocks;	232	Bu::Mutex mActiveBlocks;
233	};	233	};
234	};	234	};
235		235
236	#endif	236	#endif