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

---

VirtualFeatureTableIOBufferWriter.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_VirtualFeatureTableIOBufferWriter_h
#define Impala_Core_Feature_VirtualFeatureTableIOBufferWriter_h

#include <ctime>
#include "Core/Feature/VirtualFeatureTable.h"
#include "Core/Matrix/VirtualMatrixIOBufferWriter.h"
#include "Core/Array/WriteRaw.h"
#include "Core/Array/SetVal.h"
#include "Core/Column/Write.h"

namespace Impala
{
namespace Core
{
namespace Feature
{


class VirtualFeatureTableIOBufferWriter : public VirtualFeatureTable
{
public:

    VirtualFeatureTableIOBufferWriter(int nrVectors, int vectorLength, 
                                      Util::IOBuffer* buffer, bool ownBuffer,
                                      bool write32)
    {
        Init(nrVectors, vectorLength, buffer, ownBuffer, write32);
    }

    virtual
    ~VirtualFeatureTableIOBufferWriter()
    {
        delete mMatrix;
        mMatrix = 0;
        if (mOwnBuffer)
        {
            delete mIOBuffer;
            mIOBuffer = 0;
        }
    }

    virtual int
    Size() const
    {
        return mSize;
    }

    virtual void
    GetQuids(Table::QuidTable* quids)
    {
        ILOG_ERROR("[GetQuids] Not implemented");
    }

    virtual int
    GetVectorLength() const
    {
        return mVectorLength;
    }

    void
    AddQuids(Table::QuidTable* quids)
    {
        mIOBuffer->SetPosition(mQuidsOffset);
        Column::Write(quids->GetColumn1(), quids->Size(), mIOBuffer, true);
    }

    Matrix::VirtualMatrix*
    GetMatrix()
    {
        return mMatrix;
    }

    void
    SetCompleted()
    {
        const char* str = "impalatableversion: 2";
        mIOBuffer->SetPosition(0);
        mIOBuffer->Write(str, strlen(str));
    }

private:

    virtual int
    GetVectorImpl(int rowNr, Real64* buffer, int bufferSize)
    {
        ILOG_ERROR("[GetVectorImpl] Not implemented");
        return 0;
    }

    void
    Init(int nrVectors, int vectorLength, Util::IOBuffer* buffer,
         bool ownBuffer, bool write32)
    {
        mSize = nrVectors;
        mVectorLength = vectorLength;
        mIOBuffer = buffer;
        mOwnBuffer = ownBuffer;
        mOutputElemSize = (write32) ? 4 : 8;

        mBaseOffset = buffer->GetPosition();
        mQuidsOffset = mBaseOffset + 1024 + 128;

        // construct table header
        const int TABLEHEADERSIZE = 1024;
        std::ostringstream oss;
        oss << "incompletexxxxxxxx: 2, columns: 2, size: " << nrVectors << "\n";
        oss << "column1: object\ncolumn2: kerneldata\ninfo: no info\n";
        std::time_t rawtime;
        std::time ( &rawtime );
        oss << "computedon: " << std::ctime (&rawtime);  // ctime comes with \n
        oss << "computedby: Impala " << IMPALA_VERSION_STR
            << " (svnversion " << SVN_VERSION_STR << ") compiled "
            << __DATE__ << " " << __TIME__ << "\n";
        while(oss.tellp() < TABLEHEADERSIZE)
            oss << ' ';
        oss.seekp(TABLEHEADERSIZE - 1, std::ios::beg);
        oss << '\n';

        // write the table header
        mIOBuffer->Write(oss.str().c_str(), TABLEHEADERSIZE);

        // write footer
        Int64 footer[16];
        footer[0] = 0x6F66616C61706D69LL;
        footer[1] = 0x000000017265746FLL;
        footer[2] = 2;
        footer[3] = nrVectors;
        footer[4] = mQuidsOffset;
        footer[5] = footer[4] + 200 + nrVectors * sizeof(Int64);
        footer[6] = footer[5] + nrVectors * vectorLength * mOutputElemSize;
        for (int i=7 ; i<14 ; i++)
            footer[i] = footer[6];
        footer[14] = 0;
        footer[15] = 0;
        mIOBuffer->Write(footer, sizeof(Int64) * 16);

        // write quid space
        Array::Array2dScalarUInt64 quids(nrVectors, 1, 0, 0);
        Array::SetVal(&quids, 0);
        Array::WriteRaw(&quids, mIOBuffer, 1);

        if (mIOBuffer->GetPosition() != footer[5])
            ILOG_ERROR("Should be the same!");

        mMatrix = new Matrix::VirtualMatrixIOBufferWriter
            (mSize, mVectorLength, mIOBuffer, false, write32, true);
    }

    Util::IOBuffer*        mIOBuffer;
    bool                   mOwnBuffer;
    int                    mOutputElemSize;
    Int64                  mBaseOffset;
    Int64                  mQuidsOffset;
    Int64                  mSize;
    Int64                  mVectorLength;
    Matrix::VirtualMatrix* mMatrix;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VirtualFeatureTableIOBufferWriter, Impala.Core.Feature);

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

#endif

---