FileSystem.h

Go to the documentation of this file.

/*
 *      FileSystem.h - The Pentagram File System
 *
 *  Copyright (C) 2002-2005  The Pentagram Team
 *
 *  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.
 */

#ifndef FILESYSTEM_H
#define FILESYSTEM_H

#include <fstream>
#include <string>
#include <map>
#include <list>

#include "IDataSource.h"
#include "ODataSource.h"

class FileSystem
{
 public:
        FileSystem(bool noforcedvpaths = false);
        ~FileSystem();

        void initBuiltinData(bool allowoverride);

        static FileSystem* get_instance() { return filesystem; }

        IDataSource *ReadFile(const std::string &vfn, bool is_text=false);

        ODataSource *WriteFile(const std::string &vfn, bool is_text=false);

        bool AddVirtualPath(const std::string &vpath, const std::string &realpath,
                                                bool create=false);

        bool RemoveVirtualPath(const std::string &vpath);

        int MkDir(const std::string& path); // can handle both paths and vpaths

        typedef std::list<std::string> FileList;

        int ListFiles(const std::string mask, FileList& files);

 private:
        void switch_slashes(std::string &name);
        bool base_to_uppercase(std::string& str, int count);

        bool rawopen
        (
        std::ifstream& in,                      // Input stream to open.
        const std::string &fname,       // May be converted to upper-case.
        bool is_text = false            // Should the file be opened in text mode
        );
                
        bool rawopen
        (
        std::ofstream& out,                     // Output stream to open.
        const std::string &fname,       // May be converted to upper-case.
        bool is_text = false            // Should the file be opened in text mode
        );
        
        bool IsDir(const std::string& path);

        static FileSystem* filesystem;

        // This will disable the usage of forced virtual paths.
        // It's useful for 'tools'
        bool    noforcedvpaths;

        // This enables/disables overriding builtin data files with external ones
        bool    allowdataoverride;

        // rewrite virtual path in-place (i.e., fvn is replaced)
        // returns false if no rewriting was done
        bool rewrite_virtual_path(std::string& vfn);

        std::map<std::string, std::string> virtualpaths;

        IDataSource* checkBuiltinData(const std::string& vfn, bool is_text=false);

        struct MemoryFile
        {
                MemoryFile(const uint8* _data, const uint32 _len)
                        : data(_data), len(_len) { } 
                const uint8             *data;
                const uint32    len;
        };
        std::map<std::string, MemoryFile*> memoryfiles; // Files mounted in memory

};



#endif

---