/*

  *  VersionDictionary.h

  *  Ottoman

  *

  *  Created by Jens Alfke on 8/21/09.

  *  Copyright 2009 Jens Alfke. All rights reserved.

  *  BSD-Licensed: See the file "LICENSE.txt" for details.

  */

 #ifndef _MOOSEYARD_VERSIONDICTIONARY_

 #define _MOOSEYARD_VERSIONDICTIONARY_

 #include "Dictionary.h"

 namespace Mooseyard {

     class File;

     class Index;

     /** A persistent Dictionary embedded in a memory-mapped file, 

         representing one complete version of an Ottoman dictionary. */

     class VersionDictionary :public Dictionary {

     public:

         /** The generation number. The first version in a new file is zero. */

         int generation() const;

         /** The absolute time at which this version was written to the file. */

         time_t timestamp() const;

         /** The previous version, before this one was saved. */

         const VersionDictionary* previousVersion() const;

         /** Is this the latest version in the file? */

         bool isLatestVersion() const;

         virtual int count() const;

         virtual Blob get (Key) const;

         class Iterator;

         virtual Dictionary::Iterator* iterate() const;

         class ChangeIterator;

         /** Iterates over the changes between this dictionary and the previous version. */

         virtual ChangeIterator* iterateChanges() const;

         // Stuff you probably won't need to use:

         File* file() const                                          {return _file;}

         explicit VersionDictionary (File*);

         VersionDictionary (File *file, FilePosition trailerPosition);

     private:

         /** The type of the trailer chunk that's used as the position of the dictionary. */

         static const uint16_t kChunkType = 3;

         struct IndexPositions {

             LittleEndian<FilePosition> position[256];

             LittleEndian<FilePosition>& operator[] (int i)              {return position[i];}

             LittleEndian<FilePosition> const& operator[] (int i) const  {return position[i];}

         };

         class Trailer;

         const Trailer* _trailer() const;

         const Index* _index (int i) const;

         void _read (FilePosition trailerPosition =0);

         static FilePosition _append (const VersionDictionary *baseDict, 

                                      const Dictionary *addDict, 

                                      File *dstFile, 

                                      bool replace);

         File *_file;

         FilePosition _trailerPosition, _previousTrailerPosition;

         IndexPositions _indexPositions;

         int _count;

         mutable const VersionDictionary *_previousVersion;

 #if VERSIONDICTIONARY_TESTING

     public:

 #endif

         static VersionDictionary* create (File *file, const Dictionary *srcDict);

         VersionDictionary* byAppending (const Dictionary* d) const     {return _appendAndOpen(d,_file,false);}

         VersionDictionary* byReplacing (const Dictionary* d) const     {return _appendAndOpen(d,_file,true);}

         VersionDictionary* _appendAndOpen (const Dictionary *addDict, File *dstFile, bool replace) const;

         friend class Ottoman;

         UNCOPYABLE(VersionDictionary);

     };

     class VersionDictionary::Iterator :public Dictionary::Iterator {

     public:

         explicit Iterator (const VersionDictionary*);

         virtual ~Iterator();

         virtual Key key() const;

         virtual Blob value() const;

         virtual bool next();

         virtual bool hasValue() const;

     private:

         bool nextIndex();

         const VersionDictionary *_file;

         int _bucket;

         Dictionary::Iterator *_iter;

         UNCOPYABLE(Iterator);

     };

     class VersionDictionary::ChangeIterator :public Dictionary::Iterator {

     public:

         explicit ChangeIterator (const VersionDictionary*);

         virtual ~ChangeIterator();

         virtual Key key() const;

         virtual Blob value() const;

         virtual bool next();

         virtual bool hasValue() const;

     private:

         bool nextIndex();

         const VersionDictionary *_file;

         int _bucket;

         Dictionary::Iterator *_iter;

         UNCOPYABLE(ChangeIterator);

     };

 }

 #endif //_MOOSEYARD_VERSIONDICTIONARY_