|| || || || || ||

---

RepositoryInFileSystem.h

Go to the documentation of this file.

#ifndef Impala_Persistency_RepositoryInFileSystem_h
#define Impala_Persistency_RepositoryInFileSystem_h

#include "Persistency/File.h"
#include "Persistency/FileLocator.h"
#include "Util/SimpleMap.h"

namespace Impala
{
namespace Persistency
{


class RepositoryInFileSystem
{
public:

    static RepositoryInFileSystem&
    GetInstance()
    {
        static RepositoryInFileSystem theRepositoryInFileSystem;
        return theRepositoryInFileSystem;
    }

    // This is a very special one...
    File
    GetFile(const Locator& loc, CString fileName, bool toWrite, bool silent)
    {
        FileSystem* fs = GetFS(loc);
        String path = fs->GetFilePath(loc.GetDataSet(), fileName, toWrite,
                                      silent);
        return File(path, fs, toWrite);
    }

    File
    GetFile(const Locator& loc, CString dir, CString file, bool toWrite,
            bool silent)
    {
        FileSystem* fs = GetFS(loc);
        if (toWrite && !silent)  // silent implies "just checking"
            fs->MakeDir(dir);
        String path = fs->GetFilePath(dir, file, toWrite, silent);
        return File(path, fs, toWrite);
    }

    File
    GetFile(const FileLocator& loc, bool toWrite, bool silent)
    {
        FileSystem* fs = GetFS(loc);
        if (toWrite && !silent)   // silent implies "just checking"
            fs->MakeDir(loc.GetDir());
        String path = fs->GetFilePath("", loc.GetName(), toWrite, silent);
        return File(path, fs, toWrite);
    }

    void
    CopyFile(FileLocator srcLoc, FileLocator dstLoc)
    {
        File dstFile = GetFile(dstLoc, false, true);
        if (dstFile.Valid())
            return; // already exists, assume in sync

        dstFile = GetFile(dstLoc, true, false); // make sure dir is created
        File srcFile = GetFile(srcLoc, false, false);
        dstFile.CopyFrom(srcFile);
    }

    void
    DeleteDir(const Locator& loc, CString dir)
    {
        FileSystem* fs = GetFS(loc);
        fs->DeleteDir(dir);
    }

private:

    RepositoryInFileSystem()
    {
    }

    FileSystem*
    GetFS(const Locator& loc)
    {
        FileSystem* fs = 0;
        if (mMap.Get(loc.ToString(), fs))
            return fs;

        CmdOptions& options = CmdOptions::GetInstance();
        String setName = loc.GetDataSet();
        String data("");
        if ((setName == "dot") || (setName == ".") || (setName == "abs") ||
            (setName == "direct")) // direct is the most accurate name
        {
            data = "";
            ILOG_INFO_HEADNODE("'data' for " << setName << " is <empty>");
        }
        else if (setName == "config")
        {
            data = options.GetString("config");
            ILOG_INFO_HEADNODE("'data' for " << setName << " is " << data);
        }
        else
        {
            data = StringReplaceAll(options.GetString("data"), ":", ";", false);
            String additionalData = options.GetString("data::"+setName, "");
            if (additionalData.empty() && !setName.empty())
                additionalData = "../" + FileNameBase(setName);
            if (!additionalData.empty())
            {
                data = additionalData + ";" + data;
                ILOG_INFO_HEADNODE("'data' for " << setName << " is " << data);
            }
        }

        fs = new FileSystem(data, loc.GetHost());
        mMap.Add(loc.ToString(), fs);
        return fs;
    }

    Util::SimpleMapDelete<String, FileSystem*> mMap;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(RepositoryInFileSystem, Impala.Persistency);


static File
RepositoryGetFile(const FileLocator& loc, bool toWrite, bool silent)
{
    return RepositoryInFileSystem::GetInstance().GetFile(loc, toWrite, silent);
}

static File
RepositoryGetFile(CString fileName, bool toWrite, bool silent)
{
    FileLocator loc(fileName);
    return RepositoryInFileSystem::GetInstance().GetFile(loc, toWrite, silent);
}



} // namespace Persistency
} // namespace Impala

#endif

---