Update codebase to reflect streams/filesytem changes

CMakeLists.txt

@@ -22,7 +22,7 @@ set (INCLUDES
 	${CMAKE_SOURCE_DIR}/src/core/math
 	${CMAKE_SOURCE_DIR}/src/core/mem
 	${CMAKE_SOURCE_DIR}/src/core/compressors
-	${CMAKE_SOURCE_DIR}/src/core/streams
+	${CMAKE_SOURCE_DIR}/src/core/filesystem
 	${CMAKE_SOURCE_DIR}/src/core/strings
 	${CMAKE_SOURCE_DIR}/src/core/settings
 	${CMAKE_SOURCE_DIR}/src/os

samples/json/json.cpp

@@ -2,7 +2,7 @@
 #include <string.h>
 #include "JSONParser.h"
 #include "Filesystem.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 
 using namespace crown;
 
@@ -24,7 +24,7 @@ int main(int argc, char** argv)
 	
 	char dst[10][256];
 
-	FileStream* stream = (FileStream*)conf_root.open("json.json", SOM_READ);
+	DiskFile* stream = (DiskFile*)conf_root.open("json.json", FOM_READ);
 
  	JSONParser* parser = new JSONParser(stream);
 

src/ArchiveResourceArchive.cpp

@@ -26,7 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "ArchiveResourceArchive.h"
 #include "Filesystem.h"
 #include "Resource.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Log.h"
 
 namespace crown
@@ -40,7 +40,7 @@ ArchiveResourceArchive::ArchiveResourceArchive(Filesystem& fs) :
 	m_entries(NULL)
 {
 	// FIXME Default archive name
-	m_archive_file = (FileStream*)m_filesystem.open("archive.bin", SOM_READ);
+	m_archive_file = (DiskFile*)m_filesystem.open("archive.bin", FOM_READ);
 	
 	ArchiveHeader header;
 	
@@ -76,7 +76,7 @@ ArchiveResourceArchive::~ArchiveResourceArchive()
 }
 
 //-----------------------------------------------------------------------------
-FileStream* ArchiveResourceArchive::open(ResourceId name)
+DiskFile* ArchiveResourceArchive::open(ResourceId name)
 {
 	// Search the resource in the archive
 	for (uint32_t i = 0; i < m_entries_count; i++)
@@ -86,7 +86,7 @@ FileStream* ArchiveResourceArchive::open(ResourceId name)
 			// If found, seek to the first byte of the resource data
 			m_archive_file->seek(m_entries[i].offset);
 
-			return (FileStream*)m_archive_file;
+			return (DiskFile*)m_archive_file;
 		}
 	}
 
@@ -94,7 +94,7 @@ FileStream* ArchiveResourceArchive::open(ResourceId name)
 }
 
 //-----------------------------------------------------------------------------
-void ArchiveResourceArchive::close(FileStream* resource)
+void ArchiveResourceArchive::close(DiskFile* resource)
 {
 	// Does nothing, the stream is automatically closed at exit.
 	(void)resource;

src/ArchiveResourceArchive.h

@@ -32,7 +32,7 @@ namespace crown
 {
 
 class Filesystem;
-class FileStream;
+class DiskFile;
 
 /// Structure of the archive
 ///
@@ -62,16 +62,16 @@ public:
 					~ArchiveResourceArchive();
 
 	/// @copydoc ResourceArchive::open()
-	FileStream*		open(ResourceId name);
+	DiskFile*		open(ResourceId name);
 
 	/// @copydoc ResourceArchive::close()
-	void			close(FileStream* resource);
+	void			close(DiskFile* resource);
 
 private:
 
 	Filesystem&		m_filesystem;
 
-	FileStream*		m_archive_file;
+	DiskFile*		m_archive_file;
 
 	uint32_t		m_entries_count;
 	ArchiveEntry*	m_entries;

src/CMakeLists.txt

@@ -1,7 +1,6 @@
 set (SRC
 	Camera.cpp
 	Device.cpp
-	Filesystem.cpp
 	MaterialResource.cpp
 	ResourceManager.cpp
 	Skybox.cpp
@@ -22,7 +21,6 @@ set (HEADERS
 	Config.h
 	Crown.h
 	Device.h
-	Filesystem.h
 	Glyph.h
 	MaterialResource.h
 	Resource.h
@@ -113,27 +111,31 @@ set (MATH_HEADERS
 	core/math/Vec4.h
 )
 
-set (STREAMS_SRC
-	core/streams/FileStream.cpp
-	core/streams/MemoryStream.cpp
-	core/streams/Stream.cpp
+set (FILESYSTEM_SRC
+	core/filesystem/DiskFile.cpp
+	core/filesystem/MemoryFile.cpp
+	core/filesystem/File.cpp
 	
-	core/streams/BinaryReader.cpp
-	core/streams/BinaryWriter.cpp
-	core/streams/TextReader.cpp
-	core/streams/TextWriter.cpp
+	core/filesystem/BinaryReader.cpp
+	core/filesystem/BinaryWriter.cpp
+	core/filesystem/TextReader.cpp
+	core/filesystem/TextWriter.cpp
+
+	core/filesystem/Filesystem.cpp
 )
 
-set (STREAMS_HEADERS
-	core/streams/FileStream.h
-	core/streams/MemoryStream.h
-	core/streams/NullStream.h
-	core/streams/Stream.h
+set (FILESYSTEM_HEADERS
+	core/filesystem/DiskFile.h
+	core/filesystem/MemoryFile.h
+	core/filesystem/NullFile.h
+	core/filesystem/File.h
+
+	core/filesystem/BinaryReader.h
+	core/filesystem/BinaryWriter.h
+	core/filesystem/TextReader.h
+	core/filesystem/TextWriter.h
 
-	core/streams/BinaryReader.h
-	core/streams/BinaryWriter.h
-	core/streams/TextReader.h
-	core/streams/TextWriter.h
+	core/filesystem/Filesystem.h
 )
 
 set (STRINGS_SRC
@@ -234,7 +236,7 @@ set (CROWN_SOURCES
 	${BV_SRC}
 	${CONTAINERS_SRC}
 	${MATH_SRC}
-	${STREAMS_SRC}
+	${FILESYSTEM_SRC}
 	${MEM_SRC}
 	${COMPRESSORS_SRC}
 	${SETTINGS_SRC}
@@ -255,7 +257,7 @@ set (CROWN_HEADERS
 	${BV_HEADERS}
 	${CONTAINERS_HEADERS}
 	${MATH_HEADERS}
-	${STREAMS_HEADERS}
+	${FILESYSTEM_HEADERS}
 	${MEM_HEADERS}
 	${COMPRESSORS_HEADERS}
 	${SETTINGS_HEADERS}
@@ -297,7 +299,7 @@ install (FILES ${CORE_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core)
 install (FILES ${BV_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/bv)
 install (FILES ${CONTAINERS_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/containers)
 install (FILES ${MATH_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/math)
-install (FILES ${STREAMS_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/streams)
+install (FILES ${FILESYSTEM_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/filesystem)
 install (FILES ${MEM_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/mem)
 install (FILES ${COMPRESSORS_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/compressors)
 install (FILES ${THREADS_HEADERS} DESTINATION include/${CMAKE_PROJECT_NAME}/core/threads)

src/Crown.h

@@ -75,16 +75,16 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "MallocAllocator.h"
 #include "ProxyAllocator.h"
 
-// Core/Streams
-#include "Stream.h"
-#include "FileStream.h"
-#include "MemoryStream.h"
-#include "NullStream.h"
-
+// Core/Filesystem
+#include "File.h"
+#include "DiskFile.h"
+#include "MemoryFile.h"
+#include "NullFile.h"
 #include "BinaryReader.h"
 #include "BinaryWriter.h"
 #include "TextReader.h"
 #include "TextWriter.h"
+#include "Filesystem.h"
 
 // Core/Threads
 #include "Thread.h"
@@ -111,9 +111,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "MaterialResource.h"
 #include "FontResource.h"
 
-// Engine/Filesystem
-#include "Filesystem.h"
-
 // Engine/Input
 #include "EventDispatcher.h"
 #include "InputManager.h"

src/FileResourceArchive.cpp

@@ -27,7 +27,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "FileResourceArchive.h"
 #include "Filesystem.h"
 #include "Resource.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Log.h"
 #include "String.h"
 
@@ -46,7 +46,7 @@ FileResourceArchive::~FileResourceArchive()
 }
 
 //-----------------------------------------------------------------------------
-FileStream* FileResourceArchive::open(ResourceId name)
+DiskFile* FileResourceArchive::open(ResourceId name)
 {
 	// Convert name/type into strings
 	char resource_name[512];
@@ -60,7 +60,7 @@ FileStream* FileResourceArchive::open(ResourceId name)
 		return NULL;
 	}
 
-	FileStream* file = (FileStream*)m_filesystem.open(resource_name, SOM_READ);
+	DiskFile* file = (DiskFile*)m_filesystem.open(resource_name, FOM_READ);
 
 	file->skip(sizeof(ResourceHeader));
 
@@ -68,7 +68,7 @@ FileStream* FileResourceArchive::open(ResourceId name)
 }
 
 //-----------------------------------------------------------------------------
-void FileResourceArchive::close(FileStream* resource)
+void FileResourceArchive::close(DiskFile* resource)
 {
 	m_filesystem.close(resource);
 }

src/FileResourceArchive.h

@@ -32,7 +32,7 @@ namespace crown
 {
 
 class Filesystem;
-class FileStream;
+class DiskFile;
 
 // The header of every compiled resource file.
 // KEEP IN SYNC WITH CompiledResource struct in Compiler.h!
@@ -54,10 +54,10 @@ public:
 					~FileResourceArchive();
 
 	/// @copydoc ResourceArchive::open()
-	FileStream*		open(ResourceId name);
+	DiskFile*		open(ResourceId name);
 
 	/// @copydoc ResourceArchive::close()
-	void			close(FileStream* resource);
+	void			close(DiskFile* resource);
 
 
 private:

src/JSONParser.cpp

@@ -1,11 +1,11 @@
 #include "JSONParser.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 
 namespace crown
 {
 
 //--------------------------------------------------------------------------
-JSONParser::JSONParser(Stream* stream, size_t size)
+JSONParser::JSONParser(File* file, size_t size)
 {
 	if (size > 1024)
 	{
@@ -18,9 +18,9 @@ JSONParser::JSONParser(Stream* stream, size_t size)
 
 	m_size = size;
 
-	m_stream = stream;
+	m_file = file;
 
-	m_pos = m_stream->position();
+	m_pos = m_file->position();
 
 	m_next_token = 0;
 
@@ -67,12 +67,12 @@ JSONParser::parse()
 
 	char c;
 
-	while(!m_stream->end_of_stream())
+	while(!m_file->end_of_file())
 	{
 		JSONType type;
 
-		m_stream->read(&c, 1);
-		m_pos = m_stream->position();
+		m_file->read(&c, 1);
+		m_pos = m_file->position();
 
 		switch(c)
 		{
@@ -198,10 +198,10 @@ JSONParser::parse_string()
 
 	char c; 
 
-	while(!m_stream->end_of_stream())
+	while(!m_file->end_of_file())
 	{	
-		m_stream->read(&c, 1);
-		m_pos = m_stream->position();
+		m_file->read(&c, 1);
+		m_pos = m_file->position();
 
 		if (c == '\"' || c == '\'')
 		{
@@ -221,8 +221,8 @@ JSONParser::parse_string()
 
 		if (c == '\\')
 		{
-			m_stream->read(&c, 1);
-			m_pos = m_stream->position();
+			m_file->read(&c, 1);
+			m_pos = m_file->position();
 
 			switch(c)
 			{
@@ -256,14 +256,14 @@ JSONParser::parse_primitive()
 {
 	JSONToken* token;
 
-	int start = m_stream->position();
+	int start = m_file->position();
 
 	char c;
 
-	while (!m_stream->end_of_stream())
+	while (!m_file->end_of_file())
 	{
-		m_stream->read(&c, 1);
-		m_pos = m_stream->position();
+		m_file->read(&c, 1);
+		m_pos = m_file->position();
 
 		switch (c)
 		{
@@ -285,7 +285,7 @@ JSONParser::parse_primitive()
 
 				token->m_parent = m_prev_token;
 
-				m_stream->seek(start);
+				m_file->seek(start);
 
 				return JSON_SUCCESS;
 			}

src/JSONParser.h

@@ -2,7 +2,7 @@
 
 #include "Types.h"
 #include "OS.h"
-#include "Stream.h"
+#include "File.h"
 
 namespace crown
 {
@@ -55,7 +55,7 @@ class JSONParser
 {
 public:
 	/// Constructor
-					JSONParser(Stream* stream, size_t size = 1024);
+					JSONParser(File* file, size_t size = 1024);
 	/// Destructor
 					~JSONParser();
 	// /// Init JSON parser, must be called for each different JSON string
@@ -79,8 +79,8 @@ private:
 	/// Fill token and set boundaries
 	void			fill_token(JSONToken* token, JSONType type, int32_t start, int32_t end);
 
-	/// JSON stream of data
-	Stream*			m_stream;
+	/// JSON file of data
+	File*			m_file;
 	/// JSON string offset
 	uint32_t 		m_pos;
 	/// Next token to allocate				

src/ResourceArchive.h

@@ -49,7 +49,7 @@ struct ArchiveEntry
 };
 
 class Filesystem;
-class FileStream;
+class DiskFile;
 
 class ResourceArchive
 {
@@ -63,10 +63,10 @@ public:
 	/// The resource stream points exactly at the start
 	/// of the useful resource data, so you do not have to
 	/// care about skipping headers, metadatas and so on.
-	virtual FileStream*		open(ResourceId name) = 0;
+	virtual DiskFile*		open(ResourceId name) = 0;
 
 	/// Closes the resource file.
-	virtual void			close(FileStream* resource) = 0;
+	virtual void			close(DiskFile* resource) = 0;
 };
 
 } // namespace crown

src/ResourceManager.cpp

@@ -35,7 +35,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Device.h"
 #include "Filesystem.h"
 #include "TextReader.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "TextResource.h"
 #include "TextureResource.h"
 #include "ScriptResource.h"
@@ -54,7 +54,7 @@ ResourceManager::ResourceManager(ResourceArchive& archive, Allocator& allocator)
 	m_background_thread_should_run(true),
 	m_thread(ResourceManager::background_thread, (void*)this, "resource-loader-thread")
 {
-	FileStream* seed_file = device()->filesystem()->open("seed.ini", SOM_READ);
+	DiskFile* seed_file = device()->filesystem()->open("seed.ini", FOM_READ);
 	TextReader reader(*seed_file);
 
 	char tmp_buf[32];

src/ScriptResource.cpp

@@ -3,7 +3,7 @@
 #include "ScriptResource.h"
 #include "ResourceArchive.h"
 #include "Log.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Allocator.h"
 
 namespace crown
@@ -12,7 +12,7 @@ namespace crown
 //-----------------------------------------------------------------------------
 void* ScriptResource::load(Allocator& allocator, ResourceArchive& archive, ResourceId id)
 {
-	FileStream* stream = archive.open(id);
+	DiskFile* stream = archive.open(id);
 
 	if (stream != NULL)
 	{

src/TextResource.cpp

@@ -1,5 +1,5 @@
 #include "TextResource.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "ResourceArchive.h"
 #include "Log.h"
 #include "Allocator.h"
@@ -10,7 +10,7 @@ namespace crown
 //-----------------------------------------------------------------------------
 void* TextResource::load(Allocator& allocator, ResourceArchive& archive, ResourceId id)
 {
-	FileStream* stream = archive.open(id);
+	DiskFile* stream = archive.open(id);
 
 	CE_ASSERT(stream != NULL, "Resource does not exist: %.8X%.8X", id.name, id.type);
 

src/TextureResource.cpp

@@ -1,7 +1,7 @@
 #include "TextureResource.h"
 #include "ResourceArchive.h"
 #include "Log.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Assert.h"
 #include "Allocator.h"
 #include "Device.h"
@@ -13,7 +13,7 @@ namespace crown
 //-----------------------------------------------------------------------------
 void* TextureResource::load(Allocator& allocator, ResourceArchive& archive, ResourceId id)
 {
-	FileStream* stream = archive.open(id);
+	DiskFile* stream = archive.open(id);
 
 	CE_ASSERT(stream != NULL, "Resource does not exist: %.8X%.8X", id.name, id.type);
 

src/os/linux/CMakeLists.txt

@@ -8,7 +8,7 @@ set (LINUX_SRC
 	Input.cpp
 	../posix/TCPSocket.cpp
 	../posix/UDPSocket.cpp	
-	../posix/File.cpp
+	../posix/OsFile.cpp
 	../posix/Thread.cpp
 	../posix/Mutex.cpp
 	../posix/Cond.cpp
@@ -17,7 +17,7 @@ set (LINUX_SRC
 set (LINUX_HEADERS
 	TCPSocket.h
 	UDPSocket.h
-	File.h
+	OsFile.h
 	Thread.h
 	Mutex.h
 	Cond.h

src/os/linux/File.h → src/os/linux/OsFile.h

@@ -25,4 +25,4 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #pragma once
 
-#include "../posix/File.h"
+#include "../posix/OsFile.h"

src/os/posix/File.cpp → src/os/posix/OsFile.cpp

@@ -23,33 +23,33 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 */
 
-#include "Assert.h"
 #include <stdio.h>
 
+#include "Assert.h"
 #include "OS.h"
-#include "File.h"
+#include "OsFile.h"
 
 namespace crown
 {
 
 //-----------------------------------------------------------------------------
-File::File(const char* path, StreamOpenMode mode) :
+OsFile::OsFile(const char* path, FileOpenMode mode) :
 	m_file_handle(NULL)
 {
-	m_file_handle = fopen(path, (mode == SOM_READ) ? "rb" : "wb");
+	m_file_handle = fopen(path, (mode == FOM_READ) ? "rb" : "wb");
 	CE_ASSERT(m_file_handle != NULL, "Unable to open file: %s", path);
 
 	m_mode = mode;
 }
 
 //-----------------------------------------------------------------------------
-File::~File()
+OsFile::~OsFile()
 {
 	close();
 }
 
 //-----------------------------------------------------------------------------
-void File::close()
+void OsFile::close()
 {
 	if (m_file_handle != NULL)
 	{
@@ -59,19 +59,19 @@ void File::close()
 }
 
 //-----------------------------------------------------------------------------
-bool File::is_open() const
+bool OsFile::is_open() const
 {
 	return m_file_handle != NULL;
 }
 
 //-----------------------------------------------------------------------------
-StreamOpenMode File::mode()
+FileOpenMode OsFile::mode()
 {
 	return m_mode;
 }
 
 //-----------------------------------------------------------------------------
-size_t File::size() const
+size_t OsFile::size() const
 {
 	size_t pos = position();
 
@@ -87,7 +87,7 @@ size_t File::size() const
 }
 
 //-----------------------------------------------------------------------------
-size_t File::read(void* data, size_t size)
+size_t OsFile::read(void* data, size_t size)
 {
 	CE_ASSERT(data != NULL, "Data must be != NULL");
 
@@ -95,7 +95,7 @@ size_t File::read(void* data, size_t size)
 }
 
 //-----------------------------------------------------------------------------
-size_t File::write(const void* data, size_t size)
+size_t OsFile::write(const void* data, size_t size)
 {
 	CE_ASSERT(data != NULL, "Data must be != NULL");
 
@@ -103,34 +103,34 @@ size_t File::write(const void* data, size_t size)
 }
 
 //-----------------------------------------------------------------------------
-void File::seek(size_t position)
+void OsFile::seek(size_t position)
 {
 	int fseek_result = fseek(m_file_handle, (long) position, SEEK_SET);
 	CE_ASSERT(fseek_result == 0, "Failed to seek");
 }
 
 //-----------------------------------------------------------------------------
-void File::seek_to_end()
+void OsFile::seek_to_end()
 {
 	int fseek_result = fseek(m_file_handle, 0, SEEK_END);
 	CE_ASSERT(fseek_result == 0, "Failed to seek");
 }
 
 //-----------------------------------------------------------------------------
-void File::skip(size_t bytes)
+void OsFile::skip(size_t bytes)
 {
 	int fseek_result = fseek(m_file_handle, bytes, SEEK_CUR);
 	CE_ASSERT(fseek_result == 0, "Failed to seek");
 }
 
 //-----------------------------------------------------------------------------
-size_t File::position() const
+size_t OsFile::position() const
 {
 	return (size_t) ftell(m_file_handle);
 }
 
 //-----------------------------------------------------------------------------
-bool File::eof() const
+bool OsFile::eof() const
 {
 	return feof(m_file_handle) != 0;
 }

src/os/posix/File.h → src/os/posix/OsFile.h

@@ -28,19 +28,19 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include <cstdio>
 
 #include "Types.h"
-#include "Stream.h"
+#include "File.h"
 
 namespace crown
 {
 
 /// Standard C file wrapper
-class File
+class OsFile
 {
 public:
 
 	/// Opens the file located at @path with the given @mode.
-							File(const char* path, StreamOpenMode mode);
-							~File();
+							OsFile(const char* path, FileOpenMode mode);
+							~OsFile();
 
 	/// Closes the file.
 	void					close();
@@ -51,7 +51,7 @@ public:
 	size_t					size() const;
 
 	/// Returs the mode used to open the file.
-	StreamOpenMode			mode();
+	FileOpenMode			mode();
 
 	/// Reads @size bytes from the file and stores it into @data.
 	/// Returns the number of bytes read.
@@ -81,7 +81,7 @@ public:
 private:
 
 	FILE*					m_file_handle;
-	StreamOpenMode			m_mode;
+	FileOpenMode			m_mode;
 };
 
 } // namespace crown

tools/compilers/Compiler.cpp

@@ -28,7 +28,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Compiler.h"
 #include "Hash.h"
 #include "Path.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Log.h"
 
 namespace crown
@@ -77,13 +77,13 @@ size_t Compiler::compile(const char* resource, uint32_t name, uint32_t type)
 	}
 
 	// Read source file
-	FileStream* input_file = m_root_fs.open(resource, SOM_READ);
+	DiskFile* input_file = m_root_fs.open(resource, FOM_READ);
 
 	size_t header_size = read_header(input_file);
 	size_t resource_size = read_resource(input_file);
 
 	// Write compiled file
-	FileStream* output_file;
+	DiskFile* output_file;
 
 	if (m_dest_fs.exists(output_name))
 	{
@@ -91,7 +91,7 @@ size_t Compiler::compile(const char* resource, uint32_t name, uint32_t type)
 	}
 
 	m_dest_fs.create_file(output_name);
-	output_file = m_dest_fs.open(output_name, SOM_WRITE);
+	output_file = m_dest_fs.open(output_name, FOM_WRITE);
 
 	write_header(output_file, name, type, resource_size);
 	write_resource(output_file);
@@ -104,19 +104,19 @@ size_t Compiler::compile(const char* resource, uint32_t name, uint32_t type)
 }
 
 //-----------------------------------------------------------------------------
-size_t Compiler::read_header(FileStream* in_file)
+size_t Compiler::read_header(DiskFile* in_file)
 {
 	return read_header_impl(in_file);
 }
 
 //-----------------------------------------------------------------------------
-size_t Compiler::read_resource(FileStream* in_file)
+size_t Compiler::read_resource(DiskFile* in_file)
 {
 	return read_resource_impl(in_file);
 }
 
 //-----------------------------------------------------------------------------
-void Compiler::write_header(FileStream* out_file, uint32_t name, uint32_t type, uint32_t resource_size)
+void Compiler::write_header(DiskFile* out_file, uint32_t name, uint32_t type, uint32_t resource_size)
 {
 	CompiledHeader header;
 	header.magic = COMPILED_HEADER_MAGIC_NUMBER;
@@ -131,7 +131,7 @@ void Compiler::write_header(FileStream* out_file, uint32_t name, uint32_t type,
 }
 
 //-----------------------------------------------------------------------------
-void Compiler::write_resource(FileStream* out_file)
+void Compiler::write_resource(DiskFile* out_file)
 {
 	write_resource_impl(out_file);
 }

tools/compilers/Compiler.h

@@ -50,7 +50,7 @@ struct CompiledHeader
 	uint32_t	size;		// Size of the resource data _not_ including header (in bytes)
 };
 
-class FileStream;
+class DiskFile;
 
 /// Resource compiler interface.
 /// Every specific resource compiler must inherith from this
@@ -64,11 +64,11 @@ public:
 
 	size_t					compile(const char* resource, uint32_t name, uint32_t type);
 
-	size_t					read_header(FileStream* in_file);
-	size_t					read_resource(FileStream* in_file);
+	size_t					read_header(DiskFile* in_file);
+	size_t					read_resource(DiskFile* in_file);
 
-	void					write_header(FileStream* out_file, uint32_t name, uint32_t type, uint32_t resource_size);
-	void					write_resource(FileStream* out_file);
+	void					write_header(DiskFile* out_file, uint32_t name, uint32_t type, uint32_t resource_size);
+	void					write_resource(DiskFile* out_file);
 
 	void					cleanup();
 
@@ -78,11 +78,11 @@ public:
 
 protected:
 
-	virtual size_t			read_header_impl(FileStream* in_file) = 0;
-	virtual size_t			read_resource_impl(FileStream* in_file) = 0;
+	virtual size_t			read_header_impl(DiskFile* in_file) = 0;
+	virtual size_t			read_resource_impl(DiskFile* in_file) = 0;
 
-	virtual void			write_header_impl(FileStream* out_file) = 0;
-	virtual void			write_resource_impl(FileStream* out_file) = 0;
+	virtual void			write_header_impl(DiskFile* out_file) = 0;
+	virtual void			write_resource_impl(DiskFile* out_file) = 0;
 
 	virtual void			cleanup_impl() = 0;
 

tools/compilers/lua/LuaCompiler.cpp

@@ -24,7 +24,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "LuaCompiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Resource.h"
 #include "Log.h"
 
@@ -46,14 +46,14 @@ LuaCompiler::~LuaCompiler()
 }
 
 //-----------------------------------------------------------------------------
-size_t LuaCompiler::read_header_impl(FileStream* in_file)
+size_t LuaCompiler::read_header_impl(DiskFile* in_file)
 {
 	(void) in_file;
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
-size_t LuaCompiler::read_resource_impl(FileStream* in_file)
+size_t LuaCompiler::read_resource_impl(DiskFile* in_file)
 {
 	Filesystem fs(root_path());
 
@@ -68,7 +68,7 @@ size_t LuaCompiler::read_resource_impl(FileStream* in_file)
 		return 0;
 	}
 
-	FileStream* tmp_file = (FileStream*)fs.open(tmp_resource, SOM_READ);
+	DiskFile* tmp_file = (DiskFile*)fs.open(tmp_resource, FOM_READ);
 
 	m_file_size = tmp_file->size();
 
@@ -88,13 +88,13 @@ size_t LuaCompiler::read_resource_impl(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-void LuaCompiler::write_header_impl(FileStream* out_file)
+void LuaCompiler::write_header_impl(DiskFile* out_file)
 {
 	(void) out_file;
 }
 
 //-----------------------------------------------------------------------------
-void LuaCompiler::write_resource_impl(FileStream* out_file)
+void LuaCompiler::write_resource_impl(DiskFile* out_file)
 {
 	out_file->write(m_file_data, m_file_size);
 }

tools/compilers/lua/LuaCompiler.h

@@ -26,7 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #pragma once
 
 #include "Compiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 
 namespace crown
 {
@@ -38,11 +38,11 @@ public:
 					LuaCompiler(const char* root_path, const char* dest_path);
 					~LuaCompiler();
 
-	size_t			read_header_impl(FileStream* in_file);
-	size_t			read_resource_impl(FileStream* in_file);
+	size_t			read_header_impl(DiskFile* in_file);
+	size_t			read_resource_impl(DiskFile* in_file);
 
-	void			write_header_impl(FileStream* out_file);
-	void			write_resource_impl(FileStream* out_file);
+	void			write_header_impl(DiskFile* out_file);
+	void			write_resource_impl(DiskFile* out_file);
 
 	void			cleanup_impl();
 

tools/compilers/ps/PSCompiler.cpp

@@ -24,7 +24,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "PSCompiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Resource.h"
 
 namespace crown
@@ -45,14 +45,14 @@ PSCompiler::~PSCompiler()
 }
 
 //-----------------------------------------------------------------------------
-size_t PSCompiler::read_header_impl(FileStream* in_file)
+size_t PSCompiler::read_header_impl(DiskFile* in_file)
 {
 	(void) in_file;
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
-size_t PSCompiler::read_resource_impl(FileStream* in_file)
+size_t PSCompiler::read_resource_impl(DiskFile* in_file)
 {
 	m_file_size = in_file->size();
 
@@ -66,13 +66,13 @@ size_t PSCompiler::read_resource_impl(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-void PSCompiler::write_header_impl(FileStream* out_file)
+void PSCompiler::write_header_impl(DiskFile* out_file)
 {
 	out_file->write(&m_file_size, sizeof(uint32_t));
 }
 
 //-----------------------------------------------------------------------------
-void PSCompiler::write_resource_impl(FileStream* out_file)
+void PSCompiler::write_resource_impl(DiskFile* out_file)
 {
 	out_file->write(m_file_data, m_file_size);
 }

tools/compilers/ps/PSCompiler.h

@@ -37,11 +37,11 @@ public:
 					PSCompiler(const char* root_path, const char* dest_path);
 					~PSCompiler();
 
-	size_t			read_header_impl(FileStream* in_file);
-	size_t			read_resource_impl(FileStream* in_file);
+	size_t			read_header_impl(DiskFile* in_file);
+	size_t			read_resource_impl(DiskFile* in_file);
 
-	void			write_header_impl(FileStream* out_file);
-	void			write_resource_impl(FileStream* out_file);
+	void			write_header_impl(DiskFile* out_file);
+	void			write_resource_impl(DiskFile* out_file);
 
 	void			cleanup_impl();
 

tools/compilers/resource-linker.cpp

@@ -1,12 +1,12 @@
 #include <stdio.h>
 #include "Filesystem.h"
-#include "Stream.h"
+#include "File.h"
 #include "Path.h"
 #include "String.h"
 #include "Hash.h"
 #include "Resource.h"
 #include "ResourceArchive.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include <cstring>
 
 using namespace crown;
@@ -45,7 +45,7 @@ int main(int argc, char** argv)
 	}
 
 	// Open the archive file for both reading and writing
-	FileStream* archive = (FileStream*)fs_root.open("archive.bin", (StreamOpenMode)(SOM_READ | SOM_WRITE));
+	DiskFile* archive = (DiskFile*)fs_root.open("archive.bin", (FileOpenMode)(FOM_READ | FOM_WRITE));
 	
 	// The archive header used throughout the code
 	ArchiveHeader header;
@@ -88,7 +88,7 @@ int main(int argc, char** argv)
 	//-------------------------------------------------------------------------
 
 	// Open the resource
-	FileStream* resource = (FileStream*)fs_root.open(resource_name, SOM_READ);
+	DiskFile* resource = (DiskFile*)fs_root.open(resource_name, FOM_READ);
 	
 	// If the resource is malformed, abort
 	if (resource->size() < sizeof(ArchiveEntry))

tools/compilers/tga/TGACompiler.cpp

@@ -24,7 +24,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "TGACompiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "PixelFormat.h"
 #include "Resource.h"
 #include "Log.h"
@@ -50,7 +50,7 @@ TGACompiler::~TGACompiler()
 }
 
 //-----------------------------------------------------------------------------
-size_t TGACompiler::read_header_impl(FileStream* in_file)
+size_t TGACompiler::read_header_impl(DiskFile* in_file)
 {
 	// Read the header
 	in_file->read(&m_tga_header, sizeof(TGAHeader));
@@ -62,7 +62,7 @@ size_t TGACompiler::read_header_impl(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-size_t TGACompiler::read_resource_impl(FileStream* in_file)
+size_t TGACompiler::read_resource_impl(DiskFile* in_file)
 {
 	// Compute color channels	
 	m_image_channels = m_tga_header.pixel_depth / 8;
@@ -128,7 +128,7 @@ size_t TGACompiler::read_resource_impl(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-void TGACompiler::write_header_impl(FileStream* out_file)
+void TGACompiler::write_header_impl(DiskFile* out_file)
 {
 	// Write the texture header
 	out_file->write(&m_image_format, sizeof(PixelFormat));
@@ -137,7 +137,7 @@ void TGACompiler::write_header_impl(FileStream* out_file)
 }
 
 //-----------------------------------------------------------------------------
-void TGACompiler::write_resource_impl(FileStream* out_file)
+void TGACompiler::write_resource_impl(DiskFile* out_file)
 {
 	// Write out the data
 	out_file->write(m_image_data, m_image_size * m_image_channels);
@@ -154,7 +154,7 @@ void TGACompiler::cleanup_impl()
 }
 
 //-----------------------------------------------------------------------------
-void TGACompiler::load_uncompressed(FileStream* in_file)
+void TGACompiler::load_uncompressed(DiskFile* in_file)
 {
 	uint64_t size = m_tga_header.width * m_tga_header.height;
 
@@ -184,7 +184,7 @@ void TGACompiler::load_uncompressed(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-void TGACompiler::load_compressed(FileStream* in_file)
+void TGACompiler::load_compressed(DiskFile* in_file)
 {
 	uint8_t rle_id = 0;
 	uint32_t i = 0;

tools/compilers/tga/TGACompiler.h

@@ -26,7 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #pragma once
 
 #include "Compiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "PixelFormat.h"
 
 namespace crown
@@ -54,18 +54,18 @@ public:
 					TGACompiler(const char* root_path, const char* dest_path);
 					~TGACompiler();
 
-	size_t			read_header_impl(FileStream* in_file);
-	size_t			read_resource_impl(FileStream* in_file);
+	size_t			read_header_impl(DiskFile* in_file);
+	size_t			read_resource_impl(DiskFile* in_file);
 
-	void			write_header_impl(FileStream* out_file);
-	void			write_resource_impl(FileStream* out_file);
+	void			write_header_impl(DiskFile* out_file);
+	void			write_resource_impl(DiskFile* out_file);
 
 	void			cleanup_impl();
 
 private:
 
-	void			load_uncompressed(FileStream* in_file);
-	void			load_compressed(FileStream* in_file);
+	void			load_uncompressed(DiskFile* in_file);
+	void			load_compressed(DiskFile* in_file);
 	void			swap_red_blue();
 
 private:

tools/compilers/txt/TXTCompiler.cpp

@@ -24,7 +24,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "TXTCompiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Resource.h"
 
 namespace crown
@@ -45,14 +45,14 @@ TXTCompiler::~TXTCompiler()
 }
 
 //-----------------------------------------------------------------------------
-size_t TXTCompiler::read_header_impl(FileStream* in_file)
+size_t TXTCompiler::read_header_impl(DiskFile* in_file)
 {
 	(void) in_file;
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
-size_t TXTCompiler::read_resource_impl(FileStream* in_file)
+size_t TXTCompiler::read_resource_impl(DiskFile* in_file)
 {
 	m_file_size = in_file->size();
 
@@ -66,13 +66,13 @@ size_t TXTCompiler::read_resource_impl(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-void TXTCompiler::write_header_impl(FileStream* out_file)
+void TXTCompiler::write_header_impl(DiskFile* out_file)
 {
 	out_file->write(&m_file_size, sizeof(uint32_t));
 }
 
 //-----------------------------------------------------------------------------
-void TXTCompiler::write_resource_impl(FileStream* out_file)
+void TXTCompiler::write_resource_impl(DiskFile* out_file)
 {
 	out_file->write(m_file_data, m_file_size);
 }

tools/compilers/txt/TXTCompiler.h

@@ -26,7 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #pragma once
 
 #include "Compiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 
 namespace crown
 {
@@ -38,11 +38,11 @@ public:
 					TXTCompiler(const char* root_path, const char* dest_path);
 					~TXTCompiler();
 
-	size_t			read_header_impl(FileStream* in_file);
-	size_t			read_resource_impl(FileStream* in_file);
+	size_t			read_header_impl(DiskFile* in_file);
+	size_t			read_resource_impl(DiskFile* in_file);
 
-	void			write_header_impl(FileStream* out_file);
-	void			write_resource_impl(FileStream* out_file);
+	void			write_header_impl(DiskFile* out_file);
+	void			write_resource_impl(DiskFile* out_file);
 
 	void			cleanup_impl();
 

tools/compilers/vs/VSCompiler.cpp

@@ -24,7 +24,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "VSCompiler.h"
-#include "FileStream.h"
+#include "DiskFile.h"
 #include "Resource.h"
 
 namespace crown
@@ -45,14 +45,14 @@ VSCompiler::~VSCompiler()
 }
 
 //-----------------------------------------------------------------------------
-size_t VSCompiler::read_header_impl(FileStream* in_file)
+size_t VSCompiler::read_header_impl(DiskFile* in_file)
 {
 	(void) in_file;
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
-size_t VSCompiler::read_resource_impl(FileStream* in_file)
+size_t VSCompiler::read_resource_impl(DiskFile* in_file)
 {
 	m_file_size = in_file->size();
 
@@ -66,13 +66,13 @@ size_t VSCompiler::read_resource_impl(FileStream* in_file)
 }
 
 //-----------------------------------------------------------------------------
-void VSCompiler::write_header_impl(FileStream* out_file)
+void VSCompiler::write_header_impl(DiskFile* out_file)
 {
 	out_file->write(&m_file_size, sizeof(uint32_t));
 }
 
 //-----------------------------------------------------------------------------
-void VSCompiler::write_resource_impl(FileStream* out_file)
+void VSCompiler::write_resource_impl(DiskFile* out_file)
 {
 	out_file->write(m_file_data, m_file_size);
 }

tools/compilers/vs/VSCompiler.h

@@ -37,11 +37,11 @@ public:
 					VSCompiler(const char* root_path, const char* dest_path);
 					~VSCompiler();
 
-	size_t			read_header_impl(FileStream* in_file);
-	size_t			read_resource_impl(FileStream* in_file);
+	size_t			read_header_impl(DiskFile* in_file);
+	size_t			read_resource_impl(DiskFile* in_file);
 
-	void			write_header_impl(FileStream* out_file);
-	void			write_resource_impl(FileStream* out_file);
+	void			write_header_impl(DiskFile* out_file);
+	void			write_resource_impl(DiskFile* out_file);
 
 	void			cleanup_impl();