physfs/extras/PhysFS.NET/PhysFSFileStream.cs

/* PhysFSFileStream.cs - (c)2003 Gregory S. Read */
using System;
using System.Collections;
using System.IO;

namespace PhysFS_NET
{
   public enum PhysFSFileMode {Read, Write, Append};

   // Our exception class we'll use for throwing all PhysFS API related exception
   public class PhysFSException : IOException
   {
      public PhysFSException(string Message) : base(Message) {}
      public PhysFSException() : base(PhysFS_DLL.PHYSFS_getLastError()) {}
   }

   public unsafe class PhysFSFileStream : Stream
   {
      // ***Public properties***
      public override bool CanRead
      {
         get
         {
            // Reading is supported
            return true;
         }
      }
      
      public override bool CanSeek
      {
         get
         {
            // Seek is supported
            return true;
         }
      }

      public override bool CanWrite
      {
         get
         {
            // Writing is supported
            return true;
         }
      }

      public override long Length
      {
         get
         {
            long TempLength;
            TempLength = PhysFS_DLL.PHYSFS_fileLength(pHandle);

            // If call returned an error, throw an exception
            if(TempLength == -1)
               throw new PhysFSException();

            return TempLength;
         }
      }

      public override long Position
      {
         get
         {
            long TempPosition;
            TempPosition = PhysFS_DLL.PHYSFS_tell(pHandle);

            // If call returned an error, throw an exception
            if(TempPosition == -1)
               throw new PhysFSException();

            return TempPosition;
         }
         set
         {
            // Seek from beginning of file using the position value
            Seek(value, SeekOrigin.Begin);
         }
      }
      
      // ***Public methods***
      public PhysFSFileStream(string FileName, PhysFSFileMode FileMode, ulong BufferSize)
      {
         // Open the specified file with the appropriate file access
         switch(FileMode)
         {
            case PhysFSFileMode.Read:
               pHandle = PhysFS_DLL.PHYSFS_openRead(FileName);
               break;
            case PhysFSFileMode.Write:
               pHandle = PhysFS_DLL.PHYSFS_openWrite(FileName);
               break;
            case PhysFSFileMode.Append:
               pHandle = PhysFS_DLL.PHYSFS_openAppend(FileName);
               break;
            default:
               throw new PhysFSException("Invalid FileMode specified");
         }

         // If handle is null, an error occured, so raise an exception
         //!!! Does object get created if exception is thrown?
         if(pHandle == null)
            throw new PhysFSException();

         // Set buffer size, raise an exception if an error occured
         if(PhysFS_DLL.PHYSFS_setBuffer(pHandle, BufferSize) == 0)
            throw new PhysFSException();
      }

      // This constructor sets the buffer size to 0 if not specified
      public PhysFSFileStream(string FileName, PhysFSFileMode FileMode) : this(FileName, FileMode, 0) {}
		
      ~PhysFSFileStream()
      {
         // Don't close the handle if they've specifically closed it already
         if(!Closed)
            Close();
      }

      public override void Flush()
      {
         if(PhysFS_DLL.PHYSFS_flush(pHandle) == 0)
            throw new PhysFSException();
      }

      public override int Read(byte[] buffer, int offset, int count)
      {
         long RetValue;
   
         fixed(byte *pbytes = &buffer[offset])
         {
            // Read into our allocated pointer
            RetValue = PhysFS_DLL.PHYSFS_read(pHandle, pbytes, sizeof(byte), (uint)count);
         }

         if(RetValue == -1)
            throw new PhysFSException();

         // Return number of bytes read
         // Note: This cast should be safe since we are only reading 'count' items, which
         // is of type 'int'.
         return (int)RetValue;
      }

      public override void Write(byte[] buffer, int offset, int count)
      {
         long RetValue;

         fixed(byte* pbytes = &buffer[offset])
         {
            // Write buffer
            RetValue = PhysFS_DLL.PHYSFS_write(pHandle, pbytes, sizeof(byte), (uint)count);
         }

         if(RetValue == -1)
            throw new PhysFSException();
      }

      public override long Seek(long offset, SeekOrigin origin)
      {
         // Only seeking from beginning is supported by PhysFS API
         if(origin != SeekOrigin.Begin)
            throw new PhysFSException("Only seek origin of \"Begin\" is supported");
         
         // Seek to specified offset, raise an exception if error occured
         if(PhysFS_DLL.PHYSFS_seek(pHandle, (ulong)offset) == 0)
            throw new PhysFSException();

         // Since we always seek from beginning, the offset is always
         //  the absolute position.
         return offset;
      }

      public override void SetLength(long value)
      {
         throw new NotSupportedException("SetLength method not supported in PhysFSFileStream objects.");
      }

      public override void Close()
      {
         // Close the handle
         if(PhysFS_DLL.PHYSFS_close(pHandle) == 0)
            throw new PhysFSException();

         // File has been closed.  Rock.
         Closed = true;
      }

      // ***Private variables***
      private void *pHandle;
      private bool Closed = false;
   }
}