path.h

Go to the documentation of this file.

/* Copyright, 2000, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL 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, or (at your option)
 * any later version.

 * NEVRAX NEL 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 NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_PATH_H
#define NL_PATH_H

#include "types_nl.h"
#include "time_nl.h"

#include <map>
#include <string>
#include <vector>

#include "common.h"
#include "string_mapper.h"

namespace NLMISC {

struct EPathNotFound : public Exception
{
    EPathNotFound (const std::string& filename) : Exception ("Path not found for " + filename) { }
};

class CFileContainer
{
    // no copy allowed
    CFileContainer(const CFileContainer &/* other */)
    {}

    CFileContainer &operator =(const CFileContainer &/* other */)
    {
        return *this;
    }

public:
    CFileContainer()
    {
        _MemoryCompressed = false;
        _AllFileNames = NULL;
    }

    ~CFileContainer();


    void            addSearchPath (const std::string &path, bool recurse, bool alternative, class IProgressCallback *progressCallBack = NULL);

    void            addSearchPath (const std::string &path) { addSearchPath (path, false, true, NULL); }

    void            addSearchFile (const std::string &file, bool remap = false, const std::string &virtual_ext = "", class NLMISC::IProgressCallback *progressCallBack = NULL);

    void            addSearchListFile (const std::string &filename, bool recurse, bool alternative);

    void            addSearchBigFile (const std::string &filename, bool recurse, bool alternative, class NLMISC::IProgressCallback *progressCallBack = NULL);

    void            addSearchXmlpackFile (const std::string &sXmlpackFilename, bool recurse, bool alternative, class NLMISC::IProgressCallback *progressCallBack = NULL);

    void            removeAllAlternativeSearchPath ();

    // Remove a set of big file from the search paths (and also from CBigFile)
    void            removeBigFiles(const std::vector<std::string> &bnpFilenames);

    std::string lookup (const std::string &filename, bool throwException = true, bool displayWarning = true, bool lookupInLocalDirectory = true);

    bool            exists (const std::string &filename);


    void clearMap ();

    void remapExtension (const std::string &ext1, const std::string &ext2, bool substitute);

    void remapFile (const std::string &file1, const std::string &file2);

    void loadRemappedFiles (const std::string &file);

    void display ();

    std::string standardizePath (const std::string &path, bool addFinalSlash = true);

    std::string standardizeDosPath (const std::string &path);


    void            getPathContent (const std::string &path, bool recurse, bool wantDir, bool wantFile, std::vector<std::string> &result, class IProgressCallback *progressCallBack = NULL, bool showEverything=false);

    std::string getFullPath (const std::string &path, bool addFinalSlash = true);

    std::string getCurrentPath ();

    bool setCurrentPath (const std::string &path);

    void getFileList(const std::string &extension, std::vector<std::string> &filenames);

    void getFileListByName(const std::string &extension, const std::string &name, std::vector<std::string> &filenames);

    bool makePathRelative (const char *basePath, std::string &relativePath);

    void addIgnoredDoubleFile(const std::string &ignoredFile);

    void memoryCompress();

    void memoryUncompress();

    bool isMemoryCompressed()   { return _MemoryCompressed; }

    std::string getWindowsDirectory();

private:

    // All path in this vector must have a terminated '/'
    std::vector<std::string> _AlternativePaths;

    std::vector<std::string> IgnoredFiles;

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

    // ----------------------------------------------
    // MEMORY WISE
    // ----------------------------------------------

    bool _MemoryCompressed;
    CStaticStringMapper SSMext;
    CStaticStringMapper SSMpath;

    // If NOT memory compressed use this
    // ---------------------------------

    struct CFileEntry
    {
        std::string Name;       // Normal case
        uint32  idPath   : 16;
        uint32  idExt    : 15;
        uint32  Remapped : 1;
    };

    typedef std::map<std::string, CFileEntry>   TFiles;
    TFiles   _Files; // first is the filename in lowercase (can be with a remapped extension)



    // If memory compressed use this
    // -----------------------------

    struct CMCFileEntry
    {
        char *Name;             // Normal case (the search is done by using nlstricmp)
        uint32  idPath   : 16;  // Path (not with file at the end) - look in the SSMpath (65536 different path allowed)
        uint32  idExt    : 15;  // real extension of the file if remapped - look in the SSMext (32768 different extension allowed)
        uint32  Remapped : 1;   // true if the file is remapped
    };

    char *_AllFileNames;

    // first is the filename that can be with a remapped extension
    std::vector<CMCFileEntry> _MCFiles;

    // Compare a MCFileEntry with a lowered string (useful for MCfind)
    class CMCFileComp
    {
    public:
        sint specialCompare(const CMCFileEntry &fe, const char *rhs)
        {
            char *lhs = fe.Name;

            uint8 lchar, rchar;
            while (*lhs != '\0' && *rhs != '\0')
            {
                // lower case compare because name is in normal case
                lchar = uint8(::tolower(*lhs));
                rchar = uint8(::tolower(*rhs));
                if (lchar != rchar) return ((sint)lchar) - ((sint)rchar);
                ++lhs;
                ++rhs;
            }
            if (*lhs != 0) return 1;
            if (*rhs != 0) return -1;
            return 0;
        }

        bool operator()( const CMCFileEntry &fe, const CMCFileEntry &rhs )
        {
            return specialCompare( fe, rhs.Name ) < 0;
        }
    };

    std::vector<std::pair<std::string, std::string> > _Extensions;

    CMCFileEntry    *MCfind (const std::string &filename);
    sint            findExtension (const std::string &ext1, const std::string &ext2);
    void            insertFileInMap (const std::string &filename, const std::string &filepath, bool remap, const std::string &extension);
};


class CPath
{
    NLMISC_SAFE_SINGLETON_DECL_PTR(CPath);
public:
    static void         addSearchPath (const std::string &path, bool recurse, bool alternative, class IProgressCallback *progressCallBack = NULL);

    static void         addSearchPath (const std::string &path) { addSearchPath (path, false, true, NULL); }

    static void         addSearchFile (const std::string &file, bool remap = false, const std::string &virtual_ext = "", class NLMISC::IProgressCallback *progressCallBack = NULL);

    static void         addSearchListFile (const std::string &filename, bool recurse, bool alternative);

    static void         addSearchBigFile (const std::string &filename, bool recurse, bool alternative, class NLMISC::IProgressCallback *progressCallBack = NULL);

    static void         addSearchXmlpackFile (const std::string &sXmlpackFilename, bool recurse, bool alternative, class NLMISC::IProgressCallback *progressCallBack = NULL);

    static void         removeAllAlternativeSearchPath ();

    // Remove a set of big file from the search paths (and also from CBigFile)
    static void         removeBigFiles(const std::vector<std::string> &bnpFilenames);

    static std::string  lookup (const std::string &filename, bool throwException = true, bool displayWarning = true, bool lookupInLocalDirectory = true);

    static bool         exists (const std::string &filename);


    static void clearMap ();

    static void remapExtension (const std::string &ext1, const std::string &ext2, bool substitute);

    static void remapFile (const std::string &file1, const std::string &file2);

    static void loadRemappedFiles (const std::string &file);

    static void display ();

    static std::string  standardizePath (const std::string &path, bool addFinalSlash = true);

    static std::string  standardizeDosPath (const std::string &path);


    static void         getPathContent (const std::string &path, bool recurse, bool wantDir, bool wantFile, std::vector<std::string> &result, class IProgressCallback *progressCallBack = NULL, bool showEverything=false);

    static std::string getFullPath (const std::string &path, bool addFinalSlash = true);

    static std::string getCurrentPath ();

    static bool setCurrentPath (const std::string &path);

    static void getFileList(const std::string &extension, std::vector<std::string> &filenames);

    static void getFileListByName(const std::string &extension, const std::string &name, std::vector<std::string> &filenames);

    static bool makePathRelative (const char *basePath, std::string &relativePath);

    static void addIgnoredDoubleFile(const std::string &ignoredFile);

    static void memoryCompress();

    static void memoryUncompress();

    static bool isMemoryCompressed()    { return getInstance()->_FileContainer.isMemoryCompressed(); }

    static std::string getWindowsDirectory();

    // release singleton
    static void releaseInstance();

private:

    CPath()
    {
    }

    CFileContainer      _FileContainer;
};



struct CFile
{
    static std::string getFilename (const std::string &filename);

    static std::string getPath (const std::string &filename);

    static bool isDirectory (const std::string &filename);

    static bool fileExists (const std::string &filename);

    static bool isExists (const std::string& filename);

    static std::string findNewFile (const std::string &filename);

    static int getLastSeparator (const std::string &filename);

    static std::string getFilenameWithoutExtension (const std::string &filename);
    static std::string getExtension (const std::string &filename);

    static uint32   getFileSize (const std::string &filename);

    static uint32   getFileSize (FILE *f);

    static uint32   getFileModificationDate(const std::string &filename);

    static bool     setFileModificationDate(const std::string &filename, uint32 modTime);

    static uint32   getFileCreationDate(const std::string &filename);

    static void addFileChangeCallback (const std::string &filename, void (*)(const std::string &filename));

    static void removeFileChangeCallback (const std::string &filename);

    static void checkFileChange (TTime frequency = 1000);

    static bool copyFile(const char *dest, const char *src, bool failIfExists = false, class IProgressCallback *progress = NULL);

    static bool quickFileCompare(const std::string &fileName0, const std::string &fileName1);

    static bool thoroughFileCompare(const std::string &fileName0, const std::string &fileName1,uint32 maxBufSize=1024*1024*2);

    static bool moveFile(const char *dest, const char *src);

    static bool createDirectory(const std::string &dirname);

    static bool createDirectoryTree(const std::string &dirname);

    static bool setRWAccess(const std::string &filename);

    static bool deleteFile(const std::string &filename);

    static bool deleteDirectory(const std::string &filename);

    static void getTemporaryOutputFilename (const std::string &originalFilename, std::string &tempFilename);
};

} // NLMISC

#endif // NL_PATH_H

/* End of path.h */