/*

  *  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_