jens@0: /*
jens@0:  *  Chunk.cpp
jens@0:  *  Ottoman
jens@0:  *
jens@0:  *  Created by Jens Alfke on 8/27/09.
jens@0:  *  Copyright 2009 Jens Alfke. All rights reserved.
jens@0:  *  BSD-Licensed: See the file "LICENSE.txt" for details.
jens@0:  */
jens@0: 
jens@0: #include "Chunk.h"
jens@0: #include <assert.h>
jens@0: #include <errno.h>
jens@0: #include <stddef.h>
jens@0: 
jens@0: namespace Mooseyard {
jens@0:     
jens@0:     uint16_t Chunk::type() const {
jens@0:         return _keyLength == 0xFFFF ?(uint16_t)_type :KeyValueChunk::kChunkType;
jens@0:     }
jens@0:     
jens@0:     const KeyValueChunk* Chunk::asKeyValue() const {
jens@0:         return _keyLength == 0xFFFF ?NULL :(const KeyValueChunk*)this;
jens@0:     }
jens@0: 
jens@0:     size_t Chunk::writeMultiple (File *file, uint16_t type,
jens@0:                                  Blob blobs[], int count)  throw(File::Error) {
jens@0:         assert(type != KeyValueChunk::kChunkType);
jens@0:         Blob nuBlobs[count+1];
jens@0:         uint32_t size = sizeof(Chunk);
jens@0:         for (int i=0; i<count; i++) {
jens@0:             nuBlobs[i+1] = blobs[i];
jens@0:             size += blobs[i].length;
jens@0:         }
jens@0:         Chunk chunk(size, type);
jens@0:         nuBlobs[0] = Blob(&chunk, sizeof(chunk));
jens@0:         return file->writeMultiple(nuBlobs, count+1);
jens@0:     }
jens@0:     
jens@0:     size_t Chunk::writePadding (File *file) {
jens@0:         int padding = file->position() & 0x03;
jens@0:         if (padding == 0)
jens@0:             return 0;
jens@0:         else {
jens@0:             padding = 4 - padding;
jens@0:             uint32_t zero = 0;
jens@0:             Blob pad(&zero, padding);
jens@0:             return writeMultiple(file, kChunkTypePadding, &pad, 1);
jens@0:         }
jens@0:     }
jens@0:     
jens@0:     
jens@0:     
jens@0:     void KeyValueChunk::validate() const  throw(File::Error) {
jens@0:         if (_keyLength >= 0xFFFFU)
jens@0:             throw File::Error(ERANGE, "Invalid key length (0xFFFF)");
jens@0:         if (valuePtr() > end())
jens@0:             throw File::Error(ERANGE, "Bad KeyValueChunk (key-length too large to fit)");
jens@0:     }
jens@0:     
jens@0:     Blob KeyValueChunk::key() const {
jens@0:         return Blob(&_keyLength +1, _keyLength);  // KeyValueChunk doesn't have _type
jens@0:     }
jens@0:     
jens@0:     const char* KeyValueChunk::valuePtr() const {
jens@0:         size_t vptr = (size_t) key().end();
jens@0:         vptr = (vptr+3) & ~3;     // 4-byte align
jens@0:         return (const char*)vptr;
jens@0:     }
jens@0:     
jens@0:     Blob KeyValueChunk::value() const {
jens@0:         const char *vp = valuePtr();
jens@0:         return Blob(vp, (const char*)end()-vp);
jens@0:     }
jens@0:     
jens@0:     bool KeyValueChunk::hasKey (Blob key) const {
jens@0:         return key.length==_keyLength 
jens@0:             && memcmp(key.bytes, &_keyLength +1, key.length)==0;
jens@0:     }
jens@0:     
jens@0:     size_t KeyValueChunk::write (File* file, FilePosition pos, Blob key, Blob value)  throw(File::Error) {
jens@0:         if (key.length >= 0xFFFFU)
jens@0:             throw File::Error(ERANGE, "Key too long (>=64k)");
jens@0:         uint16_t keyLength = key.length;
jens@0:         uint32_t size = sizeof(uint32_t) + sizeof(uint16_t) + keyLength;
jens@0:         size_t pad = (pos + size) & 0x3;
jens@0:         if (pad)
jens@0:             pad = 4-pad;
jens@0:         uint32_t zeros = 0;
jens@0:         size += pad + value.length;
jens@0:         
jens@0:         Chunk chunk(size, KeyValueChunk::kChunkType);
jens@0:         chunk._keyLength = keyLength;
jens@0:         Blob b[4] = {
jens@0:             Blob(&chunk, sizeof(chunk._size)+sizeof(chunk._keyLength)),
jens@0:             key,
jens@0:             Blob(&zeros, pad),
jens@0:             value};
jens@0:         return file->writeMultiple(b,4);
jens@0:     }
jens@0: 
jens@0:     
jens@0:     
jens@0:     ChunkIterator::ChunkIterator (File* file, FilePosition start)
jens@0:         :_file(file),
jens@0:          _pos(start),
jens@0:          _length(_file->length()),
jens@0:          _chunk(NULL)
jens@0:     { 
jens@0:         _loadChunk();
jens@0:     }
jens@0:     
jens@0:     void ChunkIterator::_loadChunk() {
jens@0:         if (_pos < _length) {
jens@0:             _chunk = (const Chunk*) _file->mappedPosition(_pos);
jens@0:             if (_chunk->size() < sizeof(Chunk) || _pos+_chunk->size() > _length)
jens@0:                 _chunk = NULL;
jens@0:         } else {
jens@0:             _chunk = NULL;
jens@0:         }
jens@0: 
jens@0:     }
jens@0:     
jens@0:     bool ChunkIterator::atEOF() const {
jens@0:         return _pos == _length;
jens@0:     }
jens@0:     
jens@0:     bool ChunkIterator::next() {
jens@0:         if (_chunk) {
jens@0:             _pos += _chunk->size();
jens@0:             _loadChunk();
jens@0:         }
jens@0:         return _chunk != NULL;
jens@0:     }
jens@0:     
jens@0: }