/*

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