diff -r 000000000000 -r 31a43d94cc26 src/File.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/File.cpp	Sun Sep 20 15:14:12 2009 -0700
@@ -0,0 +1,214 @@
+/*
+ *  File.cpp
+ *  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.
+ */
+
+#include "File.h"
+#include "MemoryMap.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+namespace Mooseyard {
+    
+    File::File (const char *filename, bool writeable, bool create)  throw(Error)
+        :_fd(_check( ::open(filename, writeable ?(create ?O_RDWR|O_CREAT :O_RDWR) :O_RDONLY, 0644) )),
+         _memoryMap(NULL),
+         _locked(0)
+    { }
+
+    File::File (const char *filename, int oflag)  throw(Error)
+        :_fd(_check( ::open(filename, oflag, 0644) )),
+         _memoryMap(NULL),
+         _locked( (oflag | O_EXLOCK) ?1 :0)
+    { }
+
+    File::~File() {
+        delete _memoryMap;
+        _unlock();
+        ::close(_fd);
+    }
+    
+    
+    off_t File::length() const  throw(Error) {
+        struct stat s;
+        _check( ::fstat(_fd,&s) );
+        return s.st_size;
+    }
+     
+    void File::setLength (off_t length)  throw(Error) {
+        _check( ftruncate(_fd,length) );
+    }
+
+    off_t File::position() const  throw(Error) {
+        return _check( lseek(_fd,0,SEEK_CUR) );
+    }
+    
+    void File::setPosition (off_t pos)  throw(Error) {
+        _check( lseek(_fd,pos,SEEK_SET) );
+    }
+    
+    off_t File::setPositionToEnd (off_t bytesBefore)  throw(Error) {
+        return _check( lseek(_fd,-bytesBefore,SEEK_END) );
+    }
+    
+    void File::read (void *dst, size_t size)  throw(Error) {
+        _checkRead( ::read(_fd, dst, size), size );
+    }
+    
+    size_t File::write (const void *src, size_t size)  throw(Error) {
+        return _check( ::write(_fd, src, size) );
+    }
+    
+    
+    void File::readFrom (off_t where, void *dst, size_t size)  throw(Error) {
+        _checkRead( ::pread(_fd, dst, size, where), size );
+    }
+    
+    void File::writeTo (off_t where, const void *src, size_t size)  throw(Error) {
+        _check( ::pwrite(_fd, src, size, where) );
+    }
+    
+    size_t File::writeMultiple (Blob blobs[], int count) throw(Error) {
+        struct iovec vec[count];
+        for (int i=0; i<count; i++) {
+            vec[i].iov_base = (void*) blobs[i].bytes;
+            vec[i].iov_len = blobs[i].length;
+        }
+        return _check( ::writev(_fd, vec, count) );
+    }
+    
+    size_t File::writePadding (int alignment) {
+        off_t pad = alignment - (position() & (alignment-1));
+        if (pad == alignment)
+            return 0;
+        uint8_t zero[pad];
+        memset(zero, 0, pad);
+        return write(zero, pad);
+    }
+    
+    
+    void File::flush()  throw(Error) {
+        _check( ::fsync(_fd) );
+    }
+    
+    void File::flushDisk()  throw(Error) {
+        _check( ::fcntl(_fd,F_FULLFSYNC) );
+    }
+    
+    bool File::hasPath (const char *path) const  throw(Error) {
+        struct stat myStat, pathStat;
+        _check( ::fstat(_fd, &myStat) );
+        if ( ::stat(path, &pathStat) != 0 ) {
+            if (errno == ENOENT)
+                return false;
+            _check(errno);
+        }
+        // Compare my inode number with that of the file at path:
+        return myStat.st_ino == pathStat.st_ino;
+    }
+    
+    
+    void File::unlink (const char *filename)  throw(Error) {
+        _check( ::unlink(filename) );
+    }
+    
+    void File::rename (const char *srcFilename, const char *dstFilename)  throw(Error) {
+        _check( ::rename(srcFilename, dstFilename) );
+    }
+
+    
+#pragma mark -
+#pragma mark UTILITIES:
+    
+    int File::_check (int result)  throw(Error) {
+        if (result >= 0)
+            return result;
+        //printf("*** File::_check: Error %i: %s\n", errno, strerror(errno));
+        throw Error(errno, strerror(errno));
+    }
+    
+    void File::_checkRead (ssize_t result, size_t expectedSize)  throw(Error) {
+        if ((size_t)result < expectedSize) {
+            if (result < 0)
+                throw Error(errno, strerror(errno));
+            else
+                throw Error(kEOF, "unexpected EOF");
+        }
+    }
+    
+    File::Error::Error(const char *m)
+        :code(ERANGE), 
+         message(m) 
+    { }
+    
+    
+#pragma mark -
+#pragma mark LOCKS:
+    
+    bool File::_lock (bool block) {
+        if (_locked) {
+            _locked++;
+        } else {
+            int mode = LOCK_EX;
+            if (block)
+                mode |= LOCK_NB;
+            if (::flock(_fd, mode) == 0)
+                _locked = 1;
+            else if (errno != EWOULDBLOCK)          // may be returned in LOCK_UN mode
+                _check(-1);
+        }
+        return _locked > 0;
+    }
+    
+    void File::_unlock() {
+        if (_locked > 0) {
+            _locked--;
+            ::flock(_fd, LOCK_UN);
+        }
+    }
+    
+    File::Lock::Lock (File *file, bool block)  throw(Error)
+        :_file(file),
+         _locked( _file->_lock(block) )
+    { }
+    
+    File::Lock::~Lock() {
+        if (_locked)
+            _file->_unlock();
+    }
+    
+    bool File::Lock::retry() {
+        if (!_locked)
+            _locked = _file->_lock(false);
+        return _locked;
+    }
+    
+    
+#pragma mark -
+#pragma mark MEMORY MAP:
+    
+    MemoryMap* File::map() {
+        if (!_memoryMap)
+            _memoryMap = new MemoryMap(this);
+        return _memoryMap;
+    }
+    
+    void File::mapRegion (off_t position, size_t length) {
+        return map()->mapRegion(position,length);
+    }
+    
+    const void* File::mappedPosition (off_t position) const {
+        return map()->mappedPosition(position);
+    }
+
+}