love/src/modules/filesystem/physfs/File.cpp

/**
* Copyright (c) 2006-2011 LOVE Development Team
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
*    claim that you wrote the original software. If you use this software
*    in a product, an acknowledgment in the product documentation would be
*    appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
*    misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
**/

#include "File.h"

// STD
#include <cstring>

// LOVE
#include "Filesystem.h"
#include <filesystem/FileData.h>

namespace love
{
namespace filesystem
{
namespace physfs
{
	extern bool hack_setupWriteDirectory();

	File::File(std::string filename)
		: filename(filename), file(0), mode(filesystem::File::CLOSED)
	{
	}

	File::~File()
	{
		if (mode != CLOSED)
			close();
	}

	bool File::open(Mode mode)
	{
		if (mode == CLOSED)
			return true;

		// File must exist if read mode.
		if ((mode == READ) && !PHYSFS_exists(filename.c_str()))
			throw love::Exception("Could not open file %s. Does not exist.", filename.c_str());

		// Check whether the write directory is set.
		if ((mode == APPEND || mode == WRITE) && (PHYSFS_getWriteDir() == 0) && !hack_setupWriteDirectory())
			throw love::Exception("Could not set write directory.");

		// File already open?
		if (file != 0)
			return false;

		this->mode = mode;

		switch(mode)
		{
		case READ:
			file = PHYSFS_openRead(filename.c_str());
			break;
		case APPEND:
			file = PHYSFS_openAppend(filename.c_str());
			break;
		case WRITE:
			file = PHYSFS_openWrite(filename.c_str());
			break;
		default:
			break;
		}

		return (file != 0);
	}

	bool File::close()
	{
		if (!PHYSFS_close(file))
			return false;
		mode = CLOSED;
		file = 0;
		return true;
	}

	int64 File::getSize()
	{
		// If the file is closed, open it to
		// check the size.
		if (file == 0)
		{
			open(READ);
			int64 size = (int64)PHYSFS_fileLength(file);
			close();
			return size;
		}

		return (int64)PHYSFS_fileLength(file);
	}


	Data * File::read(int64 size)
	{
		bool isOpen = (file != 0);

		if (!isOpen && !open(READ))
			throw love::Exception("Could not read file %s.", filename.c_str());

		int64 max = (int64)PHYSFS_fileLength(file);
		size = (size == ALL) ? max : size;
		size = (size > max) ? max : size;

		FileData * fileData = new FileData(size, getFilename());

		read(fileData->getData(), size);

		if (!isOpen)
			close();

		return fileData;
	}

	int64 File::read(void * dst, int64 size)
	{
		bool isOpen = (file != 0);

		if (!isOpen)
			open(READ);

		int64 max = (int64)PHYSFS_fileLength(file);
		size = (size == ALL) ? max : size;
		size = (size > max) ? max : size;
		// Sadly, we'll have to clamp to 32 bits here
		size = (size > UINT32_MAX) ? UINT32_MAX : size;

		int64 read = (int64)PHYSFS_read(file, dst, 1, size);

		if (!isOpen)
			close();

		return read;
	}

	bool File::write(const void * data, int64 size)
	{
		if (file == 0)
			throw love::Exception("Could not write to file. File not open.");

		// Another clamp, for the time being.
		size = (size > UINT32_MAX) ? UINT32_MAX : size;

		// Try to write.
		int64 written = static_cast<int64>(PHYSFS_write(file, data, 1, size));

		// Check that correct amount of data was written.
		if (written != size)
			return false;

		return true;
	}

	bool File::write(const Data * data, int64 size)
	{
		return write(data->getData(), (size == ALL) ? data->getSize() : size);
	}

#ifdef LOVE_WINDOWS
	// MSVC doesn't like the 'this' keyword
	// well, we'll use 'that'.
	// It zigs, we zag.
	inline bool test_eof(File * that, PHYSFS_File *)
	{
		int64 pos = that->tell();
		int64 size = that->getSize();
		return pos == -1 || size == -1 || pos >= size;
	}
#else
	inline bool test_eof(File *, PHYSFS_File * file)
	{
		return PHYSFS_eof(file);
	}
#endif

	bool File::eof()
	{
		if (file == 0 || test_eof(this, file))
			return true;
		return false;
	}

	int64 File::tell()
	{
		if (file == 0)
			return -1;

		return (int64)PHYSFS_tell(file);
	}

	bool File::seek(uint64 pos)
	{
		if (file == 0)
			return false;

		if (!PHYSFS_seek(file, (PHYSFS_uint64)pos))
			return false;
		return true;
	}

	std::string File::getFilename() const
	{
		return filename;
	}

	std::string File::getExtension() const
	{
		std::string::size_type idx = filename.rfind('.');

		if (idx != std::string::npos)
			return filename.substr(idx+1);
		else
			return std::string();
	}

	filesystem::File::Mode File::getMode()
	{
		return mode;
	}

} // physfs
} // filesystem
} // love