/*

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