diff -r 000000000000 -r 31a43d94cc26 src/Chunk.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Chunk.cpp	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,135 @@
+/*
+ *  Chunk.cpp
+ *  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.
+ */
+
+#include "Chunk.h"
+#include <assert.h>
+#include <errno.h>
+#include <stddef.h>
+
+namespace Mooseyard {
+    
+    uint16_t Chunk::type() const {
+        return _keyLength == 0xFFFF ?(uint16_t)_type :KeyValueChunk::kChunkType;
+    }
+    
+    const KeyValueChunk* Chunk::asKeyValue() const {
+        return _keyLength == 0xFFFF ?NULL :(const KeyValueChunk*)this;
+    }
+
+    size_t Chunk::writeMultiple (File *file, uint16_t type,
+                                 Blob blobs[], int count)  throw(File::Error) {
+        assert(type != KeyValueChunk::kChunkType);
+        Blob nuBlobs[count+1];
+        uint32_t size = sizeof(Chunk);
+        for (int i=0; i<count; i++) {
+            nuBlobs[i+1] = blobs[i];
+            size += blobs[i].length;
+        }
+        Chunk chunk(size, type);
+        nuBlobs[0] = Blob(&chunk, sizeof(chunk));
+        return file->writeMultiple(nuBlobs, count+1);
+    }
+    
+    size_t Chunk::writePadding (File *file) {
+        int padding = file->position() & 0x03;
+        if (padding == 0)
+            return 0;
+        else {
+            padding = 4 - padding;
+            uint32_t zero = 0;
+            Blob pad(&zero, padding);
+            return writeMultiple(file, kChunkTypePadding, &pad, 1);
+        }
+    }
+    
+    
+    
+    void KeyValueChunk::validate() const  throw(File::Error) {
+        if (_keyLength >= 0xFFFFU)
+            throw File::Error(ERANGE, "Invalid key length (0xFFFF)");
+        if (valuePtr() > end())
+            throw File::Error(ERANGE, "Bad KeyValueChunk (key-length too large to fit)");
+    }
+    
+    Blob KeyValueChunk::key() const {
+        return Blob(&_keyLength +1, _keyLength);  // KeyValueChunk doesn't have _type
+    }
+    
+    const char* KeyValueChunk::valuePtr() const {
+        size_t vptr = (size_t) key().end();
+        vptr = (vptr+3) & ~3;     // 4-byte align
+        return (const char*)vptr;
+    }
+    
+    Blob KeyValueChunk::value() const {
+        const char *vp = valuePtr();
+        return Blob(vp, (const char*)end()-vp);
+    }
+    
+    bool KeyValueChunk::hasKey (Blob key) const {
+        return key.length==_keyLength 
+            && memcmp(key.bytes, &_keyLength +1, key.length)==0;
+    }
+    
+    size_t KeyValueChunk::write (File* file, FilePosition pos, Blob key, Blob value)  throw(File::Error) {
+        if (key.length >= 0xFFFFU)
+            throw File::Error(ERANGE, "Key too long (>=64k)");
+        uint16_t keyLength = key.length;
+        uint32_t size = sizeof(uint32_t) + sizeof(uint16_t) + keyLength;
+        size_t pad = (pos + size) & 0x3;
+        if (pad)
+            pad = 4-pad;
+        uint32_t zeros = 0;
+        size += pad + value.length;
+        
+        Chunk chunk(size, KeyValueChunk::kChunkType);
+        chunk._keyLength = keyLength;
+        Blob b[4] = {
+            Blob(&chunk, sizeof(chunk._size)+sizeof(chunk._keyLength)),
+            key,
+            Blob(&zeros, pad),
+            value};
+        return file->writeMultiple(b,4);
+    }
+
+    
+    
+    ChunkIterator::ChunkIterator (File* file, FilePosition start)
+        :_file(file),
+         _pos(start),
+         _length(_file->length()),
+         _chunk(NULL)
+    { 
+        _loadChunk();
+    }
+    
+    void ChunkIterator::_loadChunk() {
+        if (_pos < _length) {
+            _chunk = (const Chunk*) _file->mappedPosition(_pos);
+            if (_chunk->size() < sizeof(Chunk) || _pos+_chunk->size() > _length)
+                _chunk = NULL;
+        } else {
+            _chunk = NULL;
+        }
+
+    }
+    
+    bool ChunkIterator::atEOF() const {
+        return _pos == _length;
+    }
+    
+    bool ChunkIterator::next() {
+        if (_chunk) {
+            _pos += _chunk->size();
+            _loadChunk();
+        }
+        return _chunk != NULL;
+    }
+    
+}