/*

  *  File.h

  *  Ottoman

  *

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

  *  Copyright 2009 Jens Alfke. All rights reserved.

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

  */

 #ifndef _MOOSEYARD_FILE_

 #define _MOOSEYARD_FILE_

 #include "Base.h"

 namespace Mooseyard {

 struct Blob;

 class MemoryMap;

 /** An open file on disk; a thin wrapper around a Unix file descriptor. */

 class File {

 public:

     struct Error {

         const int code;

         const char* const message;

         Error(int c, const char *m)                                 :code(c), message(m) { }

         Error(const char *m);

     };

     static const int kEOF = 10001;

     File (const char *filename, bool writeable =false, bool create =false)  throw(Error);

     File (const char *filename, int oflag, bool locked)  throw(Error);

     ~File();

     off_t length() const  throw(Error);

     void setLength (off_t)  throw(Error);

     off_t position() const  throw(Error);

     void setPosition (off_t)  throw(Error);

     off_t setPositionToEnd (off_t bytesBefore =0)  throw(Error);

     void read (void *dst, size_t)  throw(Error);

     size_t write (const void *src, size_t)  throw(Error);

     void readFrom (off_t where, void *dst, size_t)  throw(Error);

     void writeTo (off_t where, const void *src, size_t)  throw(Error);

     size_t writeMultiple (Blob blobs[], int count)  throw(Error);

     size_t writePadding (int alignment);  // alignment should be a power of 2

     MemoryMap* map();

     const MemoryMap* map() const                            {return const_cast<File*>(this)->map();}

     void mapRegion (off_t position, size_t length);

     const void* mappedPosition (off_t position) const;

     void flush()  throw(Error);             // Regular fsync call

     void flushDisk()  throw(Error);         // Expensive F_FULLFSYNC call

     template <typename T>

     void read (T& t)  throw(Error)                              {read(&t,sizeof(t));}

     template <typename T>

     size_t write (const T& t)  throw(Error)                     {return write(&t,sizeof(t));}

     template <typename T>

     void readFrom (off_t where, T &t)  throw(Error)             {readFrom(where,&t,sizeof(t));}

     template <typename T>

     void writeTo (off_t where, const T &t)  throw(Error)        {writeTo(where,&t,sizeof(t));}

     bool hasPath (const char *path) const  throw(Error);

     static void unlink (const char *filename)  throw(Error);

     static void rename (const char *srcFilename, const char *dstFilename)  throw(Error);

     class Lock {

     public:

         Lock (File*, bool block =true)  throw(Error);

         ~Lock();

         bool isLocked() const                   {return _locked;}

         operator bool() const                   {return _locked;}

         bool retry();

     private:

         UNCOPYABLE(Lock);

         File *_file;

         int _mode;

         bool _locked;

     };

 private:

     static int _open (const char *filename, int posixMode)  throw(Error);

     static int _check (int result)  throw(Error);

 #ifdef OSX /* On linux, these are the same type signature to gcc */

     static ssize_t _check (ssize_t result)  throw(Error)    {_check((int)result); return result;}

     static off_t _check (off_t result)  throw(Error)    {_check((int)result); return result;}

 #endif

     static void _checkRead (ssize_t result, size_t expectedSize)  throw(Error);

     bool _lock (bool block);

     void _unlock();

     UNCOPYABLE(File);

     const int _fd;

     mutable MemoryMap *_memoryMap;

     int _locked;

     friend class Lock;

     friend class MemoryMap;

 };

 }

 #endif /* _MOOSEYARD_FILE_ */