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

---

KernelMatrixRepositoryInFile.h

Go to the documentation of this file.

#ifndef Impala_Persistency_KernelMatrixRepositoryInFile_h
#define Impala_Persistency_KernelMatrixRepositoryInFile_h

#include "Persistency/RepositoryInFileSystem.h"
#include "Persistency/KernelMatrixLocator.h"
#include "Core/Training/KernelMatrix.h"
#include "Persistency/DistributedAccessRepository.h"

namespace Impala
{
namespace Persistency
{


class KernelMatrixRepositoryInFile
{
public:

    typedef Core::Training::KernelMatrix KernelMatrix;
    typedef Core::Feature::FeatureTable FeatureTable;
    typedef Core::Matrix::DistributedAccess DistributedAccess;

    KernelMatrixRepositoryInFile()
    {
    }

    bool
    Exists(const KernelMatrixLocator& loc)
    {
        if (loc.GetIsIndex())
            return DistributedAccessRepository().Exists(loc);

        String dir = GetDir(loc, false);
        String fName = loc.GetFeature() + ".tab";
        File file = RepFS().GetFile(loc, dir, fName, false, true);
        return file.Valid();
    }

    KernelMatrix*
    Get(const KernelMatrixLocator& loc)
    {
        if (loc.GetIsIndex())
        {
            DistributedAccess* da = DistributedAccessRepository().Get(loc);
            KernelMatrix* res = new KernelMatrix(da);
            return res;
        }

        String dir = GetDir(loc, false);
        String fName = loc.GetFeature() + ".tab";
        File file = RepFS().GetFile(loc, dir, fName, false, false);
        if (!file.Valid())
            return 0;

        Core::Feature::FeatureDefinition def("cache");
        FeatureTable* tab = new FeatureTable(def);
        Read(tab, file);
        KernelMatrix* res = new KernelMatrix(tab);
        return res;
    }

    void
    Add(const KernelMatrixLocator& loc, KernelMatrix* mat)
    {
        if (loc.GetIsIndex())
            return DistributedAccessRepository().Add(loc, mat->GetDA());

        String dir = GetDir(loc, false);
        String fName = loc.GetFeature() + ".tab";
        File file = RepFS().GetFile(loc, dir, fName, true, false);
        Write(mat->GetFeatureTab(), file);
    }

    void
    Delete(const KernelMatrixLocator& loc)
    {
        if ((loc.GetFeature() == "ALL") && (loc.GetContainer() == "ALL"))
        {
            String dir = GetDir(loc, true);
            RepFS().DeleteDir(loc, dir);
        }
        else
        {
            String dir = GetDir(loc, false);
            ILOG_ERROR("[Delete] not fully implemented yet");
            //File file = RepFS().GetFile(loc, dir, loc.GetFeature() + ".tab",
            //                            true, true);
            //file.Delete();
        }
    }

    File
    ExposeFile(const KernelMatrixLocator& loc, bool toWrite)
    {
        if (loc.GetIsIndex())
            return DistributedAccessRepository().ExposeFile(loc, toWrite);

        String dir = GetDir(loc, false);
        String fName = loc.GetFeature() + ".tab";
        bool silent = !toWrite; // if (toWrite) force creating directory
        return RepFS().GetFile(loc, dir, fName, toWrite, silent);
    }

private:

    RepositoryInFileSystem&
    RepFS()
    {
        return RepositoryInFileSystem::GetInstance();
    }

    String
    GetDir(const KernelMatrixLocator& loc, bool forAll)
    {
        String dir = loc.GetTopString();
        if (!loc.GetIsIndex())
            dir = FileNameConcat(dir, loc.GetWalkType());

        if (forAll)
            return dir;

        dir = FileNameConcat(dir, loc.GetAnnoSet());
        dir = FileNameConcat(dir, loc.GetModel());
        dir = FileNameConcat(dir, loc.GetFeature());
        if (!loc.GetIsIndex())
            dir = FileNameConcat(dir, loc.GetContainer());
        return dir;
    }

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(KernelMatrixRepositoryInFile, Impala.Persistency);

} // namespace Persistency
} // namespace Impala

#endif

---