diff -r 000000000000 -r 31a43d94cc26 include/File.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/File.h	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,107 @@
+/*
+ *  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)  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);
+    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_