diff -r 000000000000 -r 31a43d94cc26 include/Chunk.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/Chunk.h	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,97 @@
+/*
+ *  Chunk.h
+ *  Ottoman
+ *
+ *  Created by Jens Alfke on 8/27/09.
+ *  Copyright 2009 Jens Alfke. All rights reserved.
+ *  BSD-Licensed: See the file "LICENSE.txt" for details.
+ */
+
+#ifndef _MOOSEYARD_CHUNK_
+#define _MOOSEYARD_CHUNK_
+#include "File.h"
+
+namespace Mooseyard {
+    
+    class KeyValueChunk;
+    
+#pragma pack(2)
+    
+    /** An item stored in a file. It's prefixed with its length, so that the entire file
+        can be scanned for chunks easily. */
+    class Chunk {
+    public:
+        uint32_t size() const                       {return _size;}
+        uint16_t type() const;
+        
+        /** If this is a KeyValueChunk, returns itself cast to that type, else NULL. */
+        const KeyValueChunk* asKeyValue() const;
+        
+        /** Write a Chunk to the file, in pieces a la writev. */
+        static size_t writeMultiple (File *file, uint16_t type,
+                                     Blob blobs[], int count)  throw(File::Error);
+        
+        static size_t writePadding (File *file);
+
+        static const uint16_t kChunkTypePadding = 0;
+
+        const void* end() const                     {return offsetBy(this,_size);}
+
+    protected:
+        Chunk (uint32_t size, uint16_t type)        :_size(size), _keyLength(0xFFFF), _type(type) { }
+
+    private:
+        // This is mapped to data in the file! Don't mess with it!
+        LittleEndian<uint32_t> _size;
+        LittleEndian<uint16_t> _keyLength;          // Used by KeyValueChunk; else 0xFFFF
+        LittleEndian<uint16_t> _type;               // Not used by KeyValueChunk
+        friend class KeyValueChunk;
+    };
+    
+    
+    /** A key/value pair as stored in the memory-mapped file. */
+    class KeyValueChunk :public Chunk {
+    public:
+        Blob key() const;
+        Blob value() const;
+        
+        bool hasKey (Blob key) const;
+        
+        void validate() const  throw(File::Error);
+        
+        /** Write a KeyValueChunk to a file. */
+        static size_t write (File* file, FilePosition pos, Blob key, Blob value)  throw(File::Error);
+
+        static const uint16_t kChunkType = 1;
+
+    private:
+        const char* valuePtr() const;
+    };    
+   
+#pragma options align=reset
+    
+    
+    /** An iterator over all the Chunks in a file. */
+    class ChunkIterator {
+    public:
+        ChunkIterator (File*, FilePosition start);
+        
+        const Chunk* chunk() const              {return _chunk;}
+        FilePosition position() const           {return _pos;}
+        bool atEOF() const;
+        bool next();
+        
+        operator const Chunk*() const           {return _chunk;}
+        virtual bool hasValue() const           {return _chunk != NULL;}
+        operator bool() const                   {return hasValue();}
+        ChunkIterator& operator++()             {next(); return *this;}
+    private:
+        void _loadChunk();
+        File *_file;
+        FilePosition _pos, _length;
+        const Chunk* _chunk;
+    };
+    
+}
+
+#endif _MOOSEYARD_CHUNK_