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

---

VirtualFeatureTableFactory.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_VirtualFeatureTableFactory_h
#define Impala_Core_Feature_VirtualFeatureTableFactory_h

#include "Core/Feature/VirtualFeatureTableIOBufferReader.h"
#include "Core/Feature/VirtualFeatureTableIOBufferWriter.h"
#include "Core/Feature/VirtualFeatureTableMemory.h"
#include "Persistency/FeatureTableRepository.h"
#include "Util/SimpleMap.h"

namespace Impala
{
namespace Core
{
namespace Feature
{


class VirtualFeatureTableFactory
{
public:

    static VirtualFeatureTableFactory&
    GetInstance()
    {
        static VirtualFeatureTableFactory theVirtualFeatureTableFactory;
        return theVirtualFeatureTableFactory;
    }

    VirtualFeatureTable*
    ConstructIOBufferReader(const Persistency::FeatureLocator& loc, bool cacheIt)
    {
        if (!mUseCache)
            cacheIt = false;
        Util::IOBuffer* buf = 0;
        if (mIOBuffers.Get(loc.ToString(), buf))
        {
            buf->SetPosition(0);
            return new VirtualFeatureTableIOBufferReader(buf, false);
        }
        typedef Persistency::FeatureTableRepository FeatureTableRepository;
        typedef Persistency::File File;
        File file = FeatureTableRepository().ExposeFile(loc, false);
        //buf = file.GetReadBuffer();
        buf = file.GetReadBuffer(true, "");
        if (!buf)
        {
            ILOG_ERROR("[ConstructIOBufferReader] Couldn't get readbuffer for "
                       << loc);
            return 0;
        }
        if (cacheIt)
            mIOBuffers.Add(loc.ToString(), buf);
        return new VirtualFeatureTableIOBufferReader(buf, !cacheIt);
    }

    // Up till now, this is only used to write kernel data, so interface
    // is still inconsistent...
    VirtualFeatureTableIOBufferWriter*
    ConstructIOBufferWriter(int nrVectors, int vectorLength,
                            Persistency::File file, bool write32)
    {
        Util::IOBuffer* buf = file.GetWriteBuffer();
        if (!buf)
        {
            ILOG_ERROR("[ConstructIOBufferWriter] Couldn't get writebuffer for "
                       << file.GetPath());
            return 0;
        }
        return new VirtualFeatureTableIOBufferWriter(nrVectors, vectorLength,
                                                     buf, true, write32);
    }

    VirtualFeatureTable*
    ConstructMemory(const Persistency::FeatureLocator& loc)
    {
        typedef Persistency::FeatureTableRepository FeatureTableRepository;
        FeatureTable* tab = FeatureTableRepository().Get(loc);
        if (!tab)
        {
            ILOG_ERROR("[ConstructMemory] Couldn't get " << loc);
            return 0;
        }
        return new VirtualFeatureTableMemory(tab);
    }

    void
    SetUseCache(bool flag)
    {
        mUseCache = flag;
    }

    void
    ClearCache()
    {
        mIOBuffers.Clear();
    }

private:

    VirtualFeatureTableFactory()
    {
        mUseCache = true;
        if (CmdOptions::GetInstance().GetBool("noFeatureCache"))
            mUseCache = false;
    }

    Util::SimpleMapDelete<String, Util::IOBuffer*> mIOBuffers;
    bool                                           mUseCache;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(VirtualFeatureTableFactory, Impala.Core.Feature);

} // namespace Feature
} // namespace Core
} // namespace Impala

#endif

---