+
−use std::ffi::CString;
+
−use std::io::{ Read, Write, Seek, SeekFrom, Result };
+
−use std::mem;
+
−use libc::{ c_int, c_char, c_void };
+
−use primitives::*;
+
−use super::{ PhysFSContext };
+
−use super::util::physfs_error_as_io_error;
+
−
+
−#[link(name = "physfs")]
+
−extern {
+
−    // valid filehandle on success, NULL on failure
+
−    fn PHYSFS_openAppend(filename: *const c_char) -> *const RawFile;
+
−    fn PHYSFS_openRead(filename: *const c_char) -> *const RawFile;
+
−    fn PHYSFS_openWrite(filename: *const c_char) -> *const RawFile;
+
−
+
−    // nonzero on success, 0 on failure (and the handle stays open)
+
−    // The docs make it sound like failure is rare.
+
−    fn PHYSFS_close(file: *const RawFile) -> c_int;
+
−
+
−    // Number of bytes read on success, -1 on failure.
+
−    fn PHYSFS_read(file: *const RawFile, buffer: *mut c_void,
+
−                   obj_size: PHYSFS_uint32, obj_count: PHYSFS_uint32) -> PHYSFS_sint64;
+
−
+
−    // Number of bytes written on success, -1 on failure.
+
−    fn PHYSFS_write(file: *const RawFile, buffer: *const c_void,
+
−                    obj_size: PHYSFS_uint32, obj_count: PHYSFS_uint32) -> PHYSFS_sint64;
+
−
+
−    // Flush buffered file; no-op for unbuffered files.
+
−    fn PHYSFS_flush(file: *const RawFile) -> c_int;
+
−
+
−    // Seek to position in file; nonzero on succss, zero on error.
+
−    fn PHYSFS_seek(file: *const RawFile, pos: PHYSFS_uint64) -> c_int;
+
−
+
−    // Current position in file, -1 on failure.
+
−    fn PHYSFS_tell(file: *const RawFile) -> PHYSFS_sint64;
+
−
+
−    // nonzero if EOF, zero if not.
+
−    fn PHYSFS_eof(file: *const RawFile) -> c_int;
+
−
+
−    // Determine file size; returns -1 if impossible
+
−    fn PHYSFS_fileLength(file: *const RawFile) -> PHYSFS_sint64;
+
−}
+
−
+
−/// Possible ways to open a file.
+
−#[derive(Copy, Clone)]
+
−pub enum Mode {
+
−    /// Append to the end of the file.
+
−    Append,
+
−    /// Read from the file.
+
−    Read,
+
−    /// Write to the file, overwriting previous data.
+
−    Write,
+
−}
+
−
+
−/// A wrapper for the PHYSFS_File type.
+
−#[repr(C)]
+
−struct RawFile {
+
−    opaque: *const c_void,
+
−}
+
−
+
−/// A file handle.
+
−#[allow(dead_code)]
+
−pub struct File<'f> {
+
−    raw: *const RawFile,
+
−    mode: Mode,
+
−    context: &'f PhysFSContext,
+
−}
+
−
+
−impl<'f> File<'f> {
+
−    /// Opens a file with a specific mode.
+
−    pub fn open<'g>(context: &'g PhysFSContext, filename: String, mode: Mode) -> Result<File<'g>> {
+
−        let c_filename = try!(CString::new(filename));
+
−        let raw = unsafe { match mode {
+
−            Mode::Append => PHYSFS_openAppend(c_filename.as_ptr()),
+
−            Mode::Read => PHYSFS_openRead(c_filename.as_ptr()),
+
−            Mode::Write => PHYSFS_openWrite(c_filename.as_ptr())
+
−        }};
+
−
+
−        if raw.is_null() {
+
−            Err(physfs_error_as_io_error())
+
−        }
+
−        else {
+
−            Ok(File{raw: raw, mode: mode, context: context})
+
−        }
+
−    }
+
−
+
−    /// Closes a file handle.
+
−    fn close(&self) -> Result<()> {
+
−        match unsafe {
+
−            PHYSFS_close(self.raw)
+
−        } {
+
−            0 => Err(physfs_error_as_io_error()),
+
−            _ => Ok(())
+
−        }
+
−    }
+
−
+
−    /// Checks whether eof is reached or not.
+
−    pub fn eof(&self) -> bool {
+
−        let ret = unsafe {
+
−            PHYSFS_eof(self.raw)
+
−        };
+
−
+
−        ret != 0
+
−    }
+
−
+
−    /// Determine length of file, if possible
+
−    pub fn len(&self) -> Result<u64> {
+
−        let len = unsafe { PHYSFS_fileLength(self.raw) };
+
−
+
−        if len >= 0 {
+
−            Ok(len as u64)
+
−        } else {
+
−            Err(physfs_error_as_io_error())
+
−        }
+
−    }
+
−
+
−    /// Determines current position within a file
+
−    pub fn tell(&self) -> Result<u64> {
+
−        let ret = unsafe {
+
−            PHYSFS_tell(self.raw)
+
−        };
+
−
+
−        match ret {
+
−            -1 => Err(physfs_error_as_io_error()),
+
−            _ => Ok(ret as u64)
+
−        }
+
−    }
+
−}
+
−
+
−impl<'f> Read for File<'f> {
+
−    /// Reads from a file
+
−    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+
−        let ret = unsafe {
+
−            PHYSFS_read(
+
−                self.raw,
+
−                buf.as_ptr() as *mut c_void,
+
−                mem::size_of::<u8>() as PHYSFS_uint32,
+
−                buf.len() as PHYSFS_uint32
+
−            )
+
−        };
+
−
+
−        match ret {
+
−            -1 => Err(physfs_error_as_io_error()),
+
−            _ => Ok(ret as usize)
+
−        }
+
−    }
+
−}
+
−
+
−impl<'f> Write for File<'f> {
+
−    /// Writes to a file.
+
−    /// This code performs no safety checks to ensure
+
−    /// that the buffer is the correct length.
+
−    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+
−        let ret = unsafe {
+
−            PHYSFS_write(
+
−                self.raw,
+
−                buf.as_ptr() as *const c_void,
+
−                mem::size_of::<u8>() as PHYSFS_uint32,
+
−                buf.len() as PHYSFS_uint32
+
−            )
+
−        };
+
−
+
−        match ret {
+
−            -1 => Err(physfs_error_as_io_error()),
+
−            _ => Ok(ret as usize)
+
−        }
+
−    }
+
−
+
−    /// Flushes a file if buffered; no-op if unbuffered.
+
−    fn flush(&mut self) -> Result<()> {
+
−        let ret = unsafe {
+
−            PHYSFS_flush(self.raw)
+
−        };
+
−
+
−        match ret {
+
−            0 => Err(physfs_error_as_io_error()),
+
−            _ => Ok(())
+
−        }
+
−    }
+
−}
+
−
+
−impl<'f> Seek for File<'f> {
+
−    /// Seek to a new position within a file
+
−    fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
+
−        let seek_pos = match pos {
+
−            SeekFrom::Start(n) => n as i64,
+
−            SeekFrom::End(n) => {
+
−                let len = try!(self.len());
+
−                n + len as i64
+
−            }
+
−            SeekFrom::Current(n) => {
+
−                let curr_pos = try!(self.tell());
+
−                n + curr_pos as i64
+
−            }
+
−        };
+
−
+
−        let result = unsafe {
+
−            PHYSFS_seek(
+
−                self.raw,
+
−                seek_pos as PHYSFS_uint64
+
−            )
+
−        };
+
−
+
−        if result == -1 {
+
−            return Err(physfs_error_as_io_error());
+
−        }
+
−
+
−        self.tell()
+
−    }
+
−}
+
−
+
−impl<'f> Drop for File<'f> {
+
−    fn drop(&mut self) {
+
−        let _ = self.close();
+
−    }
+
−}