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];

		this->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

		this->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];

		this->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__