blame: source/code/physfs_stream.hpp

/*

physfs_stream.hpp

    Copyright (C) 2009 Poul Sander

        Copied from Warzone 2100

        http://svn.gna.org/viewcvs/warzone/branches/sound/lib/sound/general/physfs_stream.hpp?rev=3623

	Copyright (C) 2007 Warzone Resurrection Project

	Copyright (C) 2007 Giel van Schijndel <me@mortis.eu>

	Originally part of SuperTux:

	http://svn.berlios.de/svnroot/repos/supertux/trunk/supertux/src/physfs/physfs_stream.cpp revision 4176

	Copyright (C) 2006 Matthias Braun <matze@braunis.de>

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Poul Sander

    blockattack@poulsander.com

*/

#ifndef __INCLUDED_PHYSFS_STREAM_HPP__

#define __INCLUDED_PHYSFS_STREAM_HPP__

#define BUF_SIZE 1024

#include <physfs.h>

#include <streambuf>

#include <istream>

#include <ostream>

/*Compared to Warzone 2100 boost:array has been replaced by vector to limit

 the compile requirements*/

#include <vector>

/** This an implementation of "File-based streams" as described in the

 *  ISO/IEC 14882:1998(E) C++ Standard in chapter 27 "Input/output library",

 *  section 8 "File-based streams". This implementation however uses PhysicsFS

 *  instead of the C-library's FILE functions. Also this implementation lacks

 *  an implementation of basic_fstream because PhysicsFS does not support

 *  opening a file both for reading as well as writing.

 *

 *  This header contains similar classes and typedefs as <fstream> does. Both

 *  similar in names as well as operation, the main difference is that these

 *  classes do _not_ reside in namespace std.

 */

namespace PhysFS

{

    /** Typedefinitions mandated by the C++ standard in section 27.8.1

     */

    template<typename _CharT, typename _Traits = std::char_traits<_CharT> >

        class physfs_filebuf;

    typedef physfs_filebuf<char>        filebuf;

    typedef physfs_filebuf<wchar_t>     wfilebuf;

    template<typename _CharT, typename _Traits = std::char_traits<_CharT> >

        class physfs_ifstream;

    typedef physfs_ifstream<char>       ifstream;

    typedef physfs_ifstream<wchar_t>    wifstream;

    template<typename _CharT, typename _Traits = std::char_traits<_CharT> >

        class physfs_ofstream;

    typedef physfs_ofstream<char>       ofstream;

    typedef physfs_ofstream<wchar_t>    wofstream;

    /** This class implements a C++ streambuf object for physfs files.

     *  So that you can use normal istream and ostream operations on them.

     *  This class is similar to std::basic_filebuf as defined in

     *  section 27.8.1.1, except in name.

     */

    template<typename _CharT, typename _Traits>

    class physfs_filebuf : public std::basic_streambuf<_CharT, _Traits>

    {

        public:

            // Types:

            typedef _CharT                                  char_type;

            typedef _Traits                                 traits_type;

            typedef typename traits_type::int_type          int_type;

            typedef typename traits_type::pos_type          pos_type;

            typedef typename traits_type::off_type          off_type;

            typedef std::basic_streambuf<_CharT, _Traits>   __streambuf_type;

            typedef physfs_filebuf<_CharT, _Traits>         __filebuf_type;

            physfs_filebuf() :

                _file(0)

            {

                _buf.resize(BUF_SIZE);

            }

            virtual ~physfs_filebuf()

            {

                close();

            }

            bool is_open() const throw()

            {

                return (_file != 0);

            }

            __filebuf_type* open(const char* fileName, std::ios_base::openmode mode)

            {

                // Return failure if this file buf is open already

                if (is_open() != false)

                    return 0;

                // Return failure if we are requested to open a file in an unsupported mode

                if (!(mode & std::ios_base::binary) ||

                    (mode & std::ios_base::in &&

                     mode & std::ios_base::out))

                    return 0;

                // Open the file

                if (mode & std::ios_base::out &&

                    mode & std::ios_base::app)

                {

                    _file = PHYSFS_openAppend(fileName);

                    _writeStream = true;

                }

                else if (mode & std::ios_base::out)

                {

                    _file = PHYSFS_openWrite(fileName);

                    _writeStream = true;

                }

                else if (mode & std::ios_base::in)

                {

                    _file = PHYSFS_openRead(fileName);

                    _writeStream = false;

                }

                else

                {

                    return 0;

                }

                if (!_file)

                    return 0;

                if (mode & std::ios_base::ate &&

                    mode & std::ios_base::in)

                {

                    if (!PHYSFS_seek(_file, PHYSFS_fileLength(_file)))

                    {

                        close();

                        return 0;

                    }

                }

                return this;

            }

            __filebuf_type* close()

            {

                // Return failure if this file buf is closed already

                if (is_open() == false)

                    return 0;

                sync();

                if (!PHYSFS_close(_file))

                {

                    return 0;

                }

                _file = 0;

                return this;

            }

        protected:

            // Read stuff:

            virtual int_type underflow()

            {

                if (!is_open() || _writeStream)

                    return traits_type::eof();

                if(PHYSFS_eof(_file))

                {

                    return traits_type::eof();

                }

                PHYSFS_sint64 objectsRead = PHYSFS_read(_file, &*_buf.begin(), sizeof(char_type), BUF_SIZE);

                if(objectsRead <= 0)

                {

                    return traits_type::eof();

                }

                char_type* xend = (static_cast<size_t> (objectsRead) == BUF_SIZE) ? &*_buf.end() : &_buf[objectsRead];

                setg(&*_buf.begin(), &*_buf.begin(), xend);

                return traits_type::to_int_type(_buf.front());

            }

            virtual pos_type seekpos(pos_type pos, std::ios_base::openmode)

            {

                if (!is_open() || _writeStream)

                    return pos_type(off_type(-1));

                if(PHYSFS_seek(_file, static_cast<PHYSFS_uint64> (pos)) == 0)

                {

                    return pos_type(off_type(-1));

                }

                // the seek invalidated the buffer

                setg(&*_buf.begin(), &*_buf.begin(), &*_buf.begin());

                return pos;

            }

            virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir, std::ios_base::openmode mode)

            {

                if (!is_open() || _writeStream)

                    return pos_type(off_type(-1));

                off_type pos = off;

                switch (dir)

                {

                    case std::ios_base::beg:

                        break;

                    case std::ios_base::cur:

                    {

                        PHYSFS_sint64 ptell = PHYSFS_tell(_file);

                        pos_type buf_tell = static_cast<pos_type> (ptell) - static_cast<pos_type> (__streambuf_type::egptr() - __streambuf_type::gptr());

                        if(off == 0)

                        {

                            return buf_tell;

                        }

                        pos += static_cast<off_type> (buf_tell);

                        break;

                    }

                    case std::ios_base::end:

                        pos = static_cast<off_type> (PHYSFS_fileLength(_file)) - pos;

                        break;

                    default:

                        //assert(!"invalid seekdirection");

                        return pos_type(off_type(-1));

                }

                return seekpos(static_cast<pos_type> (pos), mode);

            }

            // Write stuff:

            virtual int_type overflow(int_type c = traits_type::eof())

            {

                if (!is_open() || !_writeStream)

                    return traits_type::eof();

                size_t size = __streambuf_type::pptr() - __streambuf_type::pbase();

                if(size == 0)

                    return 0;

                PHYSFS_sint64 res = PHYSFS_write(_file, __streambuf_type::pbase(), sizeof(char_type), size);

                if(res <= 0)

                    return traits_type::eof();

                if(!traits_type::eq_int_type(c, traits_type::eof()))

                {

                    PHYSFS_sint64 res = PHYSFS_write(_file, &c, sizeof(char_type), 1);

                    if(res <= 0)

                        return traits_type::eof();

                }

                char_type* xend = (static_cast<size_t> (res) == BUF_SIZE) ? &*_buf.end() : &_buf[res];

                setp(&*_buf.begin(), xend);

                return 0;

            }

            virtual int sync()

            {

                if (!is_open() || !_writeStream)

                    return -1;

                return overflow(traits_type::eof());

            }

            virtual std::streamsize showmanyc()

            {

                if (!is_open() || _writeStream)

                    return -1;

                PHYSFS_sint64 fileSize = PHYSFS_fileLength(_file);

                return static_cast<int> (fileSize);

            }

        private:

            PHYSFS_file* _file;

            bool _writeStream;

            vector<char_type> _buf;

    };

    /** This class implements a C++ istream object for physfs files.

     *  This class is similar to std::basic_ifstream as defined in

     *  section 27.8.1.5, except in name.

     */

    template<typename _CharT, typename _Traits>

    class physfs_ifstream : public std::basic_istream<_CharT, _Traits>

    {

        public:

            // Types:

            typedef _CharT                                  char_type;

            typedef _Traits                                 traits_type;

            typedef typename traits_type::int_type          int_type;

            typedef typename traits_type::pos_type          pos_type;

            typedef typename traits_type::off_type          off_type;

            typedef physfs_filebuf<_CharT, _Traits>         __filebuf_type;

            typedef std::basic_istream<_CharT, _Traits>     __istream_type;

            physfs_ifstream() throw() :

                __istream_type(&_sb)

            {

            }

            explicit physfs_ifstream(const char* fileName, std::ios_base::openmode mode = std::ios_base::binary) :

                __istream_type(&_sb)

            {

                open(fileName, mode);

            }

            const __filebuf_type* rdbuf() const throw()

            {

                return &_sb;

            }

            __filebuf_type* rdbuf() throw()

            {

                return &_sb;

            }

            bool is_open() const throw()

            {

                return rdbuf()->is_open();

            }

            void open(const char* fileName, std::ios_base::openmode mode = std::ios_base::binary)

            {

                if (!rdbuf()->open(fileName, mode | std::ios_base::in))

                {

                    __istream_type::setstate(std::ios_base::failbit);

                }

            }

            void close()

            {

                if (!rdbuf()->close())

                {

                    __istream_type::setstate(std::ios_base::failbit);

                }

            }

        private:

            __filebuf_type _sb;

    };

    /** This class implements a C++ ostream object for physfs files.

     *  This class is similar to std::basic_ofstream as defined in

     *  section 27.8.1.8, except in name.

     */

    template<typename _CharT, typename _Traits>

    class physfs_ofstream : public std::basic_ostream<_CharT, _Traits>

    {

        public:

            // Types:

            typedef _CharT                                  char_type;

            typedef _Traits                                 traits_type;

            typedef typename traits_type::int_type          int_type;

            typedef typename traits_type::pos_type          pos_type;

            typedef typename traits_type::off_type          off_type;

            typedef physfs_filebuf<_CharT, _Traits>         __filebuf_type;

            typedef std::basic_ostream<_CharT, _Traits>     __ostream_type;

            physfs_ofstream() throw() :

                __ostream_type(&_sb)

            {

            }

            explicit physfs_ofstream(const char* fileName, std::ios_base::openmode mode = std::ios_base::binary) :

                __ostream_type(&_sb)

            {

                open(fileName, mode);

            }

            const __filebuf_type* rdbuf() const throw()

            {

                return &_sb;

            }

            __filebuf_type* rdbuf() throw()

            {

                return &_sb;

            }

            bool is_open() const throw()

            {

                return rdbuf()->is_open();

            }

            void open(const char* fileName, std::ios_base::openmode mode = std::ios_base::binary)

            {

                if (!rdbuf()->open(fileName, mode | std::ios_base::out))

                {

                    __ostream_type::setstate(std::ios_base::failbit);

                }

            }

            void close()

            {

                if (!rdbuf()->close())

                {

                    __ostream_type::setstate(std::ios_base::failbit);

                }

            }

        private:

            __filebuf_type _sb;

    };

}

#endif // __INCLUDED_PHYSFS_STREAM_HPP__