ParaScriptingIO.h

//-----------------------------------------------------------------------------
// Copyright (C) 2004 - 2006 ParaEngine Dev Studio, All Rights Reserved.
// Date:    2005.11
// Description: API for IO
//-----------------------------------------------------------------------------
#pragma once
#include "ParaScriptingCommon.h"
#include "FileSystemWatcher.h"
#include "ZipWriter.h"

namespace ParaScripting
{
    using namespace std;
    using namespace ParaEngine;
    using namespace luabind;

    class ParaFileSystemWatcher
    {
    public:
        ParaFileSystemWatcher();
#if defined(PARAENGINE_MOBILE)
        ParaFileSystemWatcher(ParaFileSystemWatcher* watcher);
#else
        ParaFileSystemWatcher(CFileSystemWatcher* watcher);
#endif

        void AddDirectory(const char* filename);
        void RemoveDirectory(const char* filename);

        void AddCallback(const char* sCallbackScript);
    public:
#if defined(PARAENGINE_MOBILE)
        ParaFileSystemWatcher* m_watcher;
#else
        CFileSystemWatcher* m_watcher;
#endif

    };

    class ParaFileObject
    {
    public:
        boost::shared_ptr<CParaFile> m_pFile;
        int m_nFromByte;
        int m_nByteCount;
        // for the get line or get file API
        std::string m_sTempBuffer;
        ParaFileObject():m_pFile(), m_nFromByte(0), m_nByteCount(-1){};
        ParaFileObject(boost::shared_ptr<CParaFile> pFile):m_pFile(pFile), m_nFromByte(0), m_nByteCount(-1){};
        ~ParaFileObject();
    public:
        bool IsValid();
        void close();

        int SetSegment(int nFromByte, int nByteCount);

        const char* GetBase64StringEx(int * pnStrLength=0);
        const char* GetBase64String();

        void seek(int offset);
        void seekRelative(int offset);
        int getpos();

        void SetFilePointer(int lDistanceToMove,int dwMoveMethod);

        bool SetEndOfFile();

        void writeline(const char* str);
        const char* readline();

        const char* GetText();

        const std::string& GetText2(int fromPos, int nCount);

        const std::string& ReadString(int nCount);

        void WriteString(const char* str);
        void WriteString2(const char* buffer, int nSize);

        void write(const char* buffer, int nSize);

        int WriteBytes(int nSize, const object& input);

        object ReadBytes(int nSize, const object& output);

        void WriteFloat(float value);
        float ReadFloat();

        void WriteWord(int value);
        int ReadWord();

        void WriteDouble(double value);
        double ReadDouble();

        void WriteInt(int value);
        int ReadInt();

        void WriteShort(int value);
        int ReadShort();

        void WriteUInt(unsigned int value);
        unsigned int ReadUInt();

        int GetFileSize();
    };

    class PE_CORE_DECL ParaSearchResult
    {
    public:
        CSearchResult * m_pResult;

        ParaSearchResult():m_pResult(NULL){};
        ParaSearchResult(CSearchResult * pResult):m_pResult(pResult){};

        bool IsValid();

        void Release();

        string GetRootPath();

        int GetNumOfResult();

        bool AddResult(const char* sItem);

        string GetItem(int nIndex);

        object GetItemData(int nIndex, const object& output);
    };

    class ParaZipWriter
    {
    public:
        ParaZipWriter();
        ParaZipWriter(CZipWriter* writer);
    public:
        ref_ptr<CZipWriter> m_writer;

    public:

        bool IsValid();

        DWORD ZipAdd(const char* dstzn, const char* fn);

        DWORD ZipAddData(const char* dstzn, const std::string& buff);

        DWORD ZipAddFolder(const char* dstzn);

        DWORD AddDirectory(const char* dstzn, const char* filepattern, int nSubLevel=0);

        DWORD close();
    };

    class PE_CORE_DECL ParaIO
    {
    public:
        ParaIO(void);
        ~ParaIO(void);
    public:

        static const char* DecodePath(const char* input);

        static const char* EncodePath(const char* input);

        static const char* EncodePath2(const char* input, const char* varNames);

        static bool AddPathVariable(const char * sVarName, const char * sVarValue);

        static bool AddSearchPath(const char* sFile);
        static bool AddSearchPath2(const char* sFile, int nPriority);

        static bool RemoveSearchPath(const char* sFile);

        static const std::string& GetWritablePath();

        static bool ClearAllSearchPath();

        static unsigned long CRC32(const char* filename);

        static void UpdateMirrorFiles(const char* dirName, bool bOverwrite);


        static ParaZipWriter CreateZip(const char *fn, const char *password);

        static int DeleteFile(const char* sFilePattern);

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

        static bool CopyFile(const char* src, const char* dest, bool bOverride);

        static ParaFileObject OpenAssetFile(const char* filename);
        static ParaFileObject OpenAssetFile2(const char* filename, bool bDownloadIfNotUpToDate);

        static bool DoesAssetFileExist(const char* filename);

        static bool DoesAssetFileExist2(const char* filename, bool bSearchZipFile);

        static int SyncAssetFile_Async(const char* filename, const char* sCallBackScript);

        static int CheckAssetFile(const char* filename);

        /* load a replace file mapping. it is just file to file pairs. If the file is requested on the left during GetFile(filename), file on the right is returned instead.
        * This function is very useful to temporarily change the 3D and 2D theme of the entire game world, in which only a text file needs to be updated.
        * The following API are also aware of replace file: DoesFileExist(), OpenFile(), OpenAssetFile(), etc.
        * @param filename: the file map file.
        * @param bReplaceExistingOnes: whether we will overwrite any previous calls to this function.
        */
        static void LoadReplaceFile(const char* filename, bool bReplaceExistingOnes);

        static ParaFileObject open(const char * filename, const char *mode);

        static ParaFileObject openimage(const char * filename, const char *mode);
        /* like openimage, but can get exinfo*/
        /*
            local exinfo = {};
            local file = ParaIO.openimage("test.jpg", "", exinfo);
            if (file) then
                print(exinfo.FocalLength);
            end
        */
        static ParaFileObject openimage2(const char * filename, const char* mode, const object& oExInfo);

        static bool CreateDirectory(const char* filename);

        static bool CreateNewFile(const char * filename);
        static bool OpenFileWrite(const char * filename);
        static bool OpenFile(const char * filename);

        static void CloseFile();
        static void WriteString(const char* str);
        static void write(const char* buffer, int nSize);

        static const char* readline();
        
        static const char* readline2(const char* prompt);

        static bool DoesFileExist(const char* filename, bool bSearchZipFiles);
        static bool DoesFileExist_(const char* filename);

        static bool BackupFile(const char* filename);

        static ParaSearchResult SearchFiles(const char* sRootPath, const char* sFilePattern, const char* sZipArchive, int nSubLevel, int nMaxFilesNum, int nFrom);
        static ParaSearchResult SearchFiles_c(const char* sRootPath, const char* sFilePattern, const char* sZipArchive, int nSubLevel);

        static string GetCurDirectory(DWORD dwDirectoryType);
        static const char* GetCurDirectory_(DWORD dwDirectoryType);

        static string GetParentDirectoryFromPath(const char* sfilename, int nParentCounts);
        static const char* GetParentDirectoryFromPath_(const char* sfilename, int nParentCounts);

        static string AutoFindParaEngineRootPath(const char* sFile);
        static const char* AutoFindParaEngineRootPath_(const char* sFile);
        static string ChangeFileExtension(const char* sFile, const string & sExt);
        static const char* ChangeFileExtension_(const char* sFile, const string & sExt);

        static string GetFileExtension(const char* sFile);
        static const char* GetFileExtension_(const char* sFile);

        static string GetRelativePath(const char* sAbsolutePath, const char* sRootPath);
        static const char* GetRelativePath_(const char* sAbsolutePath, const char* sRootPath);

        static string GetAbsolutePath(const char* sRelativePath, const char* sRootPath);
        static const char* GetAbsolutePath_(const char* sRelativePath, const char* sRootPath);

        static string GetFileName(const char* sFilePath);
        static const char* GetFileName_(const char* sFilePath);

        static int GetFileSize(const char* sFilePath);

        static bool GetFileInfo(const char* sFilePath, const object& inout);

        static string ToCanonicalFilePath(const char* sfilename, bool bBackSlash);
        static const char* ToCanonicalFilePath__(const char* sfilename, bool bBackSlash);


        static void SetDiskFilePriority(int nPriority);

        static int GetDiskFilePriority();

        static ParaFileSystemWatcher GetFileSystemWatcher(const char* filename);

        static void DeleteFileSystemWatcher(const char* name);
    };

    class ParaXML
    {
    private:
        static void LuaXML_ParseNode(lua_State *L, void* pNode);
    public:
        static int LuaXML_ParseString (lua_State *L);
        static int LuaXML_ParseFile (lua_State *L);

        static void SetCondenseWhiteSpace( bool condense );

        static bool IsWhiteSpaceCondensed();
    };
}