Started to merge @ZobyTwo cmake branch

thirdparty/zipFS/zfsystem.h

@@ -0,0 +1,332 @@
+//Important: This file has been modified in order to be integrated in to JGE++
+//
+
+// zfsystem.h: interface for the zip file system classes.
+//
+//////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2004 Tanguy Fautre
+//
+//  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.
+//
+//  Tanguy Fautr<74>E
+//  softdev@telenet.be
+//
+//////////////////////////////////////////////////////////////////////
+//
+//							Zip File System.
+//							****************
+//
+// Current version: 1.00 BETA 2 (16/07/2004)
+//
+// Comment: -
+//
+// History: - 1.00 BETA 2 (16/07/2004) - Updated to follow latest version
+//                                       of fileio.h
+//          - 1.00 BETA 1 (21/07/2002) - First public release
+//
+//////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+
+#include "stdafx.h"
+#include "ziphdr.h"		// Zip file header
+#include "zstream.h"	// Zip Stream
+
+
+
+// Zip File System Namespace
+namespace zip_file_system {
+
+
+
+
+class filesystem;
+
+
+
+// Input Zip File class
+class izfstream : public izstream
+{
+public:
+	izfstream(filesystem * pFS = pDefaultFS);
+	izfstream(const char * FilePath, filesystem * pFS = pDefaultFS);
+
+	void open(const char * FilePath, filesystem * pFS = pDefaultFS);
+	void close();
+
+	bool is_open() const;
+
+    void setFS(filesystem * pFS = pDefaultFS);
+
+	bool Zipped() const;
+    bool isBeingUsed() const;
+	const std::string & FilePath() const;
+	const std::string & FullFilePath() const;
+    size_t getUncompSize();
+    size_t getOffset();
+    size_t getCompSize();
+
+protected:
+	friend class filesystem;
+
+	// Default File System Pointer (default = NULL)
+	static filesystem * pDefaultFS;
+
+	std::string m_FilePath;
+	std::string m_FullFilePath;
+	filesystem * m_pFS;
+	bool m_Zipped;
+    size_t m_UncompSize;
+	size_t	m_Offset;
+	size_t	m_CompSize;
+    bool m_Used;
+        
+};
+
+
+
+
+// Zip File System central class
+class filesystem  
+{
+public:
+	// "local" file info class
+	class file_info
+	{
+	public:
+		file_info() : m_PackID(0), m_Offset(0), m_Size(0), m_CompSize(0), m_CompMethod(0), m_Directory(true) { }
+		file_info(size_t PackID, size_t Offset, size_t Size, size_t CompSize, short CompMethod, bool Directory) :
+			m_PackID(PackID), m_Offset(Offset), m_Size(Size), m_CompSize(CompSize), m_CompMethod(CompMethod), m_Directory(Directory) { }
+
+		size_t	m_PackID;
+		size_t	m_Offset;
+		size_t	m_Size;
+		size_t	m_CompSize;
+		short	m_CompMethod;
+		bool	m_Directory;
+	};
+
+	class limited_file_info
+	{
+	public:
+		limited_file_info() :  m_Offset(0), m_Size(0) { }
+		limited_file_info(size_t Offset, size_t Size) :
+			m_Offset(Offset), m_Size(Size) { }
+
+		size_t	m_Offset;
+		size_t	m_Size;
+	};
+
+    class pooledBuffer
+    {
+    public:
+        pooledBuffer(std::string filename, std::string externalFilename ) : filename(filename), externalFilename(externalFilename), buffer(NULL) {}
+        ~pooledBuffer() { if (buffer) { delete buffer; } }
+        std::string filename;
+        std::string externalFilename;
+        zbuffer * buffer;
+    };
+
+
+	filesystem(const char * BasePath = "", const char * FileExt = "zip", bool DefaultFS = true); 
+	~filesystem();
+
+	void MakeDefault();
+	void Open(izfstream & File, const char * Filename);
+    bool DirExists(const std::string & folderName);
+    bool FileExists(const std::string & fileName);
+    bool PreloadZip(const char * Filename, std::map<std::string, limited_file_info>& target);
+    static std::string getCurrentZipName();
+    static filesystem * getCurrentFS();
+    static std::streamoff SkipLFHdr(std::istream & File, std::streamoff LFHdrPos);
+    void unuse(izfstream & File);
+
+    //Fills the vector results with a list of children of the given folder
+    std::vector<std::string>& scanfolder(const std::string& folderName, std::vector<std::string>& results);
+
+	friend std::ostream & operator << (std::ostream & Out, const filesystem & FS);
+    static void closeTempFiles();
+    
+protected:
+
+
+
+	// Zip file info class
+	class zipfile_info
+	{
+	public:
+		zipfile_info() : m_NbEntries(0), m_FilesSize(0), m_FilesCompSize(0) { }
+
+		std::string	m_Filename;
+		size_t		m_NbEntries;
+		size_t		m_FilesSize;
+		size_t		m_FilesCompSize;
+	};
+
+	// Class for file path string comparaison
+	struct lt_path
+	{
+		bool operator() (const std::string & s1, const std::string & s2) const;
+	};
+
+
+	// Protected member functions
+	// Zip file format related functions
+	std::streamoff CentralDir(std::istream & File) const;
+    std::streamoff CentralDirZipped(std::istream & File, std::streamoff begin, std::size_t size) const;
+	headerid NextHeader(std::istream & File) const;
+
+	// File/Zip map related functions
+	bool FileNotZipped(const char * FilePath) const;
+	bool FindFile(const char * Filename, file_info * FileInfo) const;
+	const std::string & FindZip(size_t PackID) const;
+	void InsertZip(const char * Filename, const size_t PackID);
+
+    static zbuffer * getValidBuffer(const std::string & filename, const std::string & externalFilename, std::streamoff Offset = 0, std::streamoff Size = 0);
+    static void closeBufferPool();
+
+	// New type definitions
+	typedef std::map<size_t, zipfile_info>								zipmap;
+	typedef std::map<size_t, zipfile_info>::iterator					zipmap_iterator;
+	typedef std::map<size_t, zipfile_info>::const_iterator				zipmap_const_iterator;
+	typedef std::map<std::string, file_info, lt_path>					filemap;
+	typedef std::map<std::string, file_info, lt_path>::iterator			filemap_iterator;
+	typedef std::map<std::string, file_info, lt_path>::const_iterator	filemap_const_iterator;
+
+	// Mighty protected member variables
+	std::string	m_BasePath;
+	std::string	m_FileExt;
+	zipmap		m_Zips;
+	filemap		m_Files;
+    static std::vector<pooledBuffer *> m_Buffers;
+    static std::ifstream CurrentZipFile;
+    static std::string CurrentZipName;
+    static filesystem * pCurrentFS;
+};
+
+
+
+
+//////////////////////////////////////////////////////////////////////
+// zip_file_system::izfile Inline Functions
+//////////////////////////////////////////////////////////////////////
+
+inline izfstream::izfstream(filesystem * pFS) : m_pFS(pFS) { }
+
+inline izfstream::izfstream(const char * FilePath, filesystem * pFS) : m_pFS(pFS) {
+	open(FilePath);
+}
+
+inline void izfstream::setFS(filesystem * pFS) {
+    m_pFS = pFS;
+}
+
+inline size_t izfstream::getUncompSize()
+{
+    return m_UncompSize;
+}
+
+inline size_t izfstream::getOffset()
+{
+    return m_Offset;
+}
+
+inline size_t izfstream::getCompSize()
+{
+    return m_CompSize;
+}
+
+
+
+inline void izfstream::open(const char * FilePath, filesystem * pFS) {
+    if (pFS)
+        m_pFS = pFS;
+
+	if (m_pFS != NULL)
+		m_pFS->Open(* this, FilePath);
+}
+
+inline void izfstream::close() {
+#ifdef USE_ZBUFFER_POOL 
+	if (m_pFS)
+        m_pFS->unuse( * this);
+#else
+    izstream::close();
+#endif
+	m_FilePath = m_FullFilePath = "";
+    m_UncompSize = 0;
+}
+
+inline bool izfstream::is_open() const {
+	return static_cast<zbuffer *>(rdbuf())->is_open();
+}
+
+inline bool izfstream::Zipped() const {
+	return m_Zipped;
+}
+
+inline bool izfstream::isBeingUsed() const {
+	return m_Used;
+}
+
+inline const std::string & izfstream::FilePath() const {
+	return m_FilePath;
+}
+
+inline const std::string & izfstream::FullFilePath() const {
+	return m_FullFilePath;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+// zip_file_system::filesystem Inline Functions
+//////////////////////////////////////////////////////////////////////
+
+inline filesystem::~filesystem() {
+	// Security mesure with izfile::pDefaultFS
+	if (izfstream::pDefaultFS == this)
+		izfstream::pDefaultFS = NULL;
+}
+
+inline void filesystem::closeTempFiles() {
+    if (CurrentZipName.size())
+    {
+        CurrentZipFile.close();
+        CurrentZipName = "";
+    }
+    closeBufferPool();
+}
+inline void filesystem::MakeDefault() {
+	izfstream::pDefaultFS = this;
+}
+
+
+inline std::string filesystem::getCurrentZipName()
+{
+    return CurrentZipName;
+}
+
+inline filesystem * filesystem::getCurrentFS()
+{
+    return pCurrentFS;
+}
+
+}	// namespace zip_file_system
+