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

---

KernelMatrixLocator.h

Go to the documentation of this file.

#ifndef Impala_Persistency_KernelMatrixLocator_h
#define Impala_Persistency_KernelMatrixLocator_h

#include "Persistency/Locator.h"
#include "Core/Feature/FeatureDefinition.h"

namespace Impala
{
namespace Persistency
{


class KernelMatrixLocator : public Locator
{
public:

    KernelMatrixLocator()
    {
    }

    KernelMatrixLocator(CString protocolAndHost, CString dataSet,
                        bool isIndex, CString walkType, CString annoSet,
                        String model, String feature, CString container)
        : Locator(protocolAndHost, dataSet)
    {
        mIsIndex = isIndex;
        mWalkType = walkType;
        mAnnoSet = annoSet;
        mFeatureIndexCat = "";
        mModel = model;
        mFeature = feature;
        mContainer = container;
        mStartNode = -1;
        mNodeCount = -1;
        mDoParts = 1;
        mEmployReal32 = false;
        mWriteReal32 = false;
        mIncrement = 0;
    }

    KernelMatrixLocator(CString dataSet, bool isIndex, CString walkType,
                        CString annoSet, String model, String feature,
                        CString container, CmdOptions& options)
        : Locator(dataSet, options)
    {
        mIsIndex = isIndex;
        mWalkType = walkType;
        mAnnoSet = annoSet;
        mFeatureIndexCat = "";
        mModel = model;
        mFeature = feature;
        mContainer = container;
        mStartNode = -1;
        mNodeCount = -1;
        mDoParts = 1;
        mEmployReal32 = false;
        mWriteReal32 = false;
        mIncrement = 0;
    }

    KernelMatrixLocator(const Locator& base, bool isIndex, CString walkType,
                        CString annoSet, String model, String feature,
                        CString container)
        : Locator(base.GetProtocol(), base.GetHost(), base.GetDataSet())
    {
        mIsIndex = isIndex;
        mWalkType = walkType;
        mAnnoSet = annoSet;
        mFeatureIndexCat = "";
        mModel = model;
        mFeature = feature;
        mContainer = container;
        mStartNode = -1;
        mNodeCount = -1;
        mDoParts = 1;
        mEmployReal32 = false;
        mWriteReal32 = false;
        mIncrement = 0;
    }

    virtual
    ~KernelMatrixLocator()
    {
    }

    bool
    GetIsIndex() const
    {
        return mIsIndex;
    }

    String
    GetTopString() const
    {
        if (mIsIndex)
            return "KernelIndex";
        return "KernelData";
    }

    String
    GetWalkType() const
    {
        return mWalkType;
    }

    void
    SetWalkType(CString walkType)
    {
        mWalkType = walkType;
    }

    String
    GetAnnoSet() const
    {
        return mAnnoSet;
    }

    String
    GetFeatureIndexCat() const
    {
        return mFeatureIndexCat;
    }

    void
    SetFeatureIndexCat(CString featureIndexCat)
    {
        mFeatureIndexCat = featureIndexCat;
    }

    String
    GetModel() const
    {
        return mModel;
    }

    String
    GetFeature() const
    {
        return mFeature;
    }

    String
    GetContainer() const
    {
        return mContainer;
    }

    void
    SetContainer(CString container)
    {
        mContainer = container;
    }

    int
    GetStartNode() const
    {
        return mStartNode;
    }

    void
    SetStartNode(int node)
    {
        mStartNode = node;
    }

    int
    GetNodeCount() const
    {
        return mNodeCount;
    }

    void
    SetNodeCount(int count)
    {
        mNodeCount = count;
    }

    int
    GetDoParts() const
    {
        return mDoParts;
    }

    void
    SetDoParts(int mode)
    {
        mDoParts = mode;
    }

    bool
    GetEmployReal32() const
    {
        return mEmployReal32;
    }

    void
    SetEmployReal32(bool flag)
    {
        mEmployReal32 = flag;
    }

    bool
    GetWriteReal32() const
    {
        return mWriteReal32;
    }

    void
    SetWriteReal32(bool flag)
    {
        mWriteReal32 = flag;
    }

    int
    GetIncrement() const
    {
        return mIncrement;
    }

    void
    SetIncrement(int val)
    {
        mIncrement = val;
    }

    String
    ToString() const
    {
        return "KernelMatrixLocator(" + GetProtocol() + "," + GetHost()
            + "," + GetDataSet() + "," + GetTopString() + ","
            + GetWalkType() + "," + GetAnnoSet() + "," + GetModel() + ","
            + GetFeature() + "," + GetContainer() + ")";
    }

private:

    bool   mIsIndex;
    String mWalkType;
    String mAnnoSet;
    String mFeatureIndexCat;
    String mModel;
    String mFeature;
    String mContainer;
    int    mStartNode;
    int    mNodeCount;
    int    mDoParts; // mode = 0 : don't read/write parts
                     // mode = 1 : read parts into memory
                     // mode = 2 : read parts from file when requested
                     // mode = 3 : write parts into one file
    bool   mEmployReal32;
    bool   mWriteReal32;
    int    mIncrement;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(KernelMatrixLocator, Impala.Persistency);

std::ostream&
operator<< (std::ostream& os, const KernelMatrixLocator& loc)
{
    os << loc.ToString();
    return os;
}

} // namespace Persistency
} // namespace Impala

#endif

---