VFileSystem.h

Go to the documentation of this file.

#ifndef __LDK_VFILESYSTEM_H__
#define __LDK_VFILESYSTEM_H__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   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.
//



#include "LDK/Types.h"
#include "LDK/VFile.h"
#include "LDK/String.h"
#include <vector>
#include <list>

namespace LDK
{
typedef std::vector<String,Allocator<String> > StringVec;
typedef SmartPointer<StringVec> SmartStringVec;

namespace Details
{
class LDK_API PerThreadVFS
{
    SmartFile mStdIn;
    SmartFile mStdOut;
    SmartFile mStdErr;
public:
    PerThreadVFS();
    ~PerThreadVFS();

    inline SmartFile& stdIn()  { return mStdIn; }
    inline SmartFile& stdOut() { return mStdOut; }
    inline SmartFile& stdErr() { return mStdErr; }
    void stdIn(SmartFile f);
    void stdOut(SmartFile f);
    void stdErr(SmartFile f);
};
}//namespace Details

class LDK_API VFileSystem : public Singleton<Details::PerThreadVFS>
{

private:

    static void cleanup();
    VFileSystem();
    VFileSystem(const VFileSystem&);
    VFileSystem(const VFileSystem*);
    ~VFileSystem();

public:

    static void initialise(const char* argv0);

    inline static SmartFile stdIn() { return instance().stdIn(); }

    inline static SmartFile stdOut() { return instance().stdOut(); }

    inline static SmartFile stdErr() { return instance().stdErr(); }

    inline static void stdIn(SmartFile f) { instance().stdIn(f); }

    inline static void stdOut(SmartFile f) { instance().stdOut(f); }

    inline static void stdErr(SmartFile f) { instance().stdErr(f); }

    static void defaultConfig(const char* organisation, const char* appName,
        const char* archiveExt, bool includeCdRoms, bool archivesFirst);

    static void addToSearchPath(const char* dirName, bool append=true);

    static void removeFromSearchPath(const char* dirName);

    static void writeDir(const char* dirName);

    static const char* writeDir();

    static SmartFile openRead(const char* fileName, bool text);

    static SmartFile openWrite(const char* fileName, bool text);

    static SmartFile openAppend(const char* fileName, bool text);

    static SmartStringVec searchDirs();

    static SmartStringVec cdRomDirs();

    static SmartStringVec enumerateFiles(const char* dir);

    static const char* dirSeperator();

    static const char* baseDir();

    static const char* userDir();

    static void makeDir(const char* dirName);

    static bool isDir(const char* fileName);

    static void deleteFile(const char* fileName);

    static const char* realDirectory(const char* fileName);

    static bool exists(const char* fileName);
};

}//namespace LDK

#endif //__LDK_VFILESYSTEM_H__

---