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

---

VirtualMatrixFactory.h

Go to the documentation of this file.

#ifndef Impala_Core_Matrix_VirtualMatrixFactory_h
#define Impala_Core_Matrix_VirtualMatrixFactory_h

#include "Core/Matrix/VirtualMatrixIOBufferReader.h"
#include "Core/Matrix/VirtualMatrixIOBufferWriter.h"
#include "Core/Matrix/VirtualMatrixMemory.h"

namespace Impala
{
namespace Core
{
namespace Matrix
{


class VirtualMatrixFactory
{
public:

    static VirtualMatrixFactory&
    GetInstance()
    {
        static VirtualMatrixFactory theVirtualMatrixFactory;
        return theVirtualMatrixFactory;
    }

    VirtualMatrix*
    ConstructIOBufferReader(Persistency::File file)
    {
        Util::IOBuffer* buf = file.GetReadBuffer();
        if (!buf)
        {
            ILOG_ERROR("[ConstructIOBufferReader] Couldn't get readbufer");
            return 0;
        }
        Array::ArrayType at = Array::ReadRawArrayType(buf);
        buf->SetPosition(0);
        if (at == Array::ARRAY2DSCALARREAL32)
            return new VirtualMatrixIOBufferReader<Mat32>(buf, true);
        else
            return new VirtualMatrixIOBufferReader<Mat>(buf, true);
    }

    VirtualMatrix*
    ConstructIOBufferWriter(int nrRow, int nrCol, Persistency::File file,
                            bool write32, bool preWrite)
    {
        Util::IOBuffer* buf = file.GetWriteBuffer();
        if (!buf)
        {
            ILOG_ERROR("[ConstructIOBufferWriter] Couldn't get writebufer for"
                       << file.GetPath());
            return 0;
        }
        return new VirtualMatrixIOBufferWriter(nrRow, nrCol, buf, true, write32,
                                               preWrite);
    }

    VirtualMatrix*
    ConstructMemory(Persistency::File file, bool employ32)
    {
        Matrix::Mat* m = 0;
        Matrix::Mat32* m32 = 0;
        Array::ArrayType at = Array::ReadRawArrayType(file);
        if (at == Array::ARRAY2DSCALARREAL32)
        {
            Array::ReadRaw(m32, file);
        }
        else if (at == Array::ARRAY2DSCALARREAL64)
        {
            Array::ReadRaw(m, file);
        }
        else
        {
            ILOG_ERROR("[ConstructMemory] Couldn't read matrix");
            return 0;
        }

        if ((m == 0) && (m32 == 0))
        {
            ILOG_ERROR_NODE("[ConstructMemory] Couldn't read matrix");
            return 0;
        }

        if (employ32 && (m32 == 0))
        {
            Array::Set(m32, m);
            delete m;
            m = 0;
        }

        if (m)
            return ConstructMemory<Matrix::Mat>(m);
        else
            return ConstructMemory<Matrix::Mat32>(m32);
    }

    template <class ArrayT>
    VirtualMatrix*
    ConstructMemory(ArrayT* mat)
    {
        return new VirtualMatrixMemory<ArrayT>(mat);
    }

private:

    VirtualMatrixFactory()
    {
    }

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(VirtualMatrixFactory, Impala.Core.Matrix);

} // namespace Matrix
} // namespace Core
} // namespace Impala

#endif

---