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

---

VideoSetsRepository.h

Go to the documentation of this file.

#ifndef Impala_Persistency_VideoSetsRepository_h
#define Impala_Persistency_VideoSetsRepository_h

#include "Basis/Quids.h"
#include "Basis/QuidObj.h"
#include "Persistency/Locator.h"
#include "Util/SimpleMap.h"
#include "Util/StringParser.h"
#include "Persistency/RepositoryInMonetDB.h"
#include "Persistency/RepositoryInFileSystem.h"

namespace Impala
{

// For forward declaration of VideoSet
namespace Core
{
namespace VideoSet
{

class VideoSet;

} // namespace VideoSet
} // namespace Core


namespace Persistency
{


class VideoSetsRepository
{
public:

    typedef Core::VideoSet::VideoSet VideoSet;

    static VideoSetsRepository&
    GetInstance()
    {
        static VideoSetsRepository theVideoSetsRepository;
        return theVideoSetsRepository;
    }

    bool
    Contains(CString setName) const
    {
        int id = 0;
        return mIdMap.GetIdx(FileNameBase(setName), id);
    }

    int
    GetId(CString setName) const
    {
        int id = 0;
        mIdMap.GetIdx(FileNameBase(setName), id);
        return id;
    }

    std::vector<int>
    GetAllId() const
    {
        return mIdMap.GetAllIdx();
    }

    String
    GetSetName(int id) const
    {
        String res = "unknown";
        mIdMap.Get(id, res);
        return res;
    }

    void
    Register(VideoSet* vs, String setName)
    {
        if (setName.empty())
        {
            ILOG_ERROR("Cannot find 'setName' because it is empty");
            return;
        }
        int id = GetId(setName);
        if (id == 0)
        {
            ILOG_ERROR("Register: Cannot find id for set named: " << setName);
            return;
        }
        mSetMap.Add(id, vs);
    }

    VideoSet*
    GetVideoSet(int id) const
    {
        VideoSet* res = 0;
        if (! mSetMap.Get(id, res))
            ILOG_INFO("Couldn't find VideoSet with id = " << id);
        return res;
    }

    VideoSet*
    GetVideoSet(Quid quid) const
    {
        return GetVideoSet(QuidSet(quid));
    }

    String
    QuidToString(Quid quid, bool elaborate)
    {
        QuidObj qObj(quid);
        if (!elaborate)
            return qObj.ToString();
        String setName = "unknown";
        mIdMap.Get(qObj.Set(), setName);
        return "Q(" + QuidClassToString(qObj.Class()) + "," + setName + "," +
            MakeString(qObj.Object()) + "," + MakeString(qObj.Id()) + ")";
    }

    void
    CopyTo(const Locator& dstLoc) const
    {
        String protocol = dstLoc.GetProtocol();
        if (protocol == "mapi")
        {
            CopyToMonetDB(dstLoc);
        }
        else
        {
            ILOG_ERROR("Copy: unknown protocol: " << protocol);
        }
    }

    void
    Dump() const
    {
        mIdMap.Dump("VideoSets: ");
    }

private:

    typedef Link::Monet::Connection Connection;

    VideoSetsRepository()
    {
        CmdOptions& options = CmdOptions::GetInstance();
        Locator loc("config", options);
        ILOG_DEBUG("ctor: loc = " << loc);
        String protocol = loc.GetProtocol();
        if ((protocol == "file") || (protocol == "dataServer"))
        {
            GetFromFileSystem(loc);
        }
        else if (protocol == "mapi")
        {
            GetFromMonetDB(loc);
        }
        else if (protocol == "inMem")
        {
            mIdMap.Add(1, "volatile"); // repos contains one and only one video set
        }
        else
        {
            ILOG_ERROR("Get: unknown protocol: " << protocol);
        }
    }

    void
    GetFromFileSystem(const Locator& loc)
    {
        ILOG_DEBUG("GetFromFileSystem");
        CmdOptions& options = CmdOptions::GetInstance();
        String repName = options.GetString("videoSetsRepository");
        File f = RepositoryInFileSystem::GetInstance().GetFile(loc, repName,
                                                               false, false);
        Util::IOBuffer* buf = f.GetReadBuffer();
        if (buf)
        {
            while (buf->Available())
            {
                String line = buf->ReadLine();
                if (line[0] && (line[0] != '#'))
                {
                    Util::StringParser p(line);
                    int setId = p.GetInt();
                    if ((setId <= 0) || (setId > 255))
                        ILOG_ERROR("setId out of range [0-255]");
                    String setName = p.GetString2(false);
                    mIdMap.Add(setId, setName);
                }
            }
            delete buf;
        }
    }

    void
    GetFromMonetDB(const Locator& loc)
    {
        ILOG_DEBUG("GetFromMonetDB");
        Connection* conn = RepositoryInMonetDB::GetInstance().GetConnection(loc);

        String query =
            "select identifier, set_name \
             from   video_sets \
             order by identifier;";

        MapiHdl hdl = conn->QueryPartStart(query);
        if (hdl == 0)
            return;

        int* id = 0;
        int idSize = 0;
        if (!conn->QueryPartFetchInt(hdl, 0, id, idSize))
            return;

        std::vector<String> sName;
        if (!conn->QueryPartFetchString(hdl, 1, sName))
            return;

        conn->QueryPartEnd(hdl);

        for (int i=0 ; i<idSize ; i++)
        {
            mIdMap.Add(id[i], sName[i]);
        }
        delete id;
    }

    void
    CopyToMonetDB(const Locator& loc) const
    {
        Connection* conn = RepositoryInMonetDB::GetInstance().GetConnection(loc);

        std::vector<int> ids = GetAllId();
        for (int i=0 ; i<ids.size() ; i++)
        {
            String name = GetSetName(ids[i]);
            String q = "select i_add_video_set(" + MakeString(ids[i])
                + ", '" + name + "');";
            ILOG_INFO("q = [" + q + "]");
            conn->Query(q, false, false);
        }
    }

    String                          mFileName;
    Util::SimpleMap<int, String>    mIdMap;
    Util::SimpleMap<int, VideoSet*> mSetMap;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VideoSetsRepository, Impala.Persistency);

} // namespace Persistency
} // namespace Impala

#endif

---