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

---

WritableTableDataSource.h

Go to the documentation of this file.

#ifndef MediaTable_WritableTableDataSource_h
#define MediaTable_WritableTableDataSource_h

#include "TableDataSource.h"

namespace Impala {
namespace Application {
namespace MediaTable {

class WritableTableDataSource : public TableDataSource, public TableDataSourceListener
{
public:

    WritableTableDataSource() : TableDataSource()
    {
        Init();
    }

    ~WritableTableDataSource()
    {
        ILOG_DEBUG("Destroying WritableTableDataSource @ " << this);
    }

    int GetTotalRows() {
        if (mTotalRows >= 0) return mTotalRows;
        std::map<std::string, std::vector<int> >::iterator                                      mIntMapIterator;
        std::map<std::string, std::vector<double> >::iterator                           mDoubleMapIterator;
        std::map<std::string, std::vector<std::string> >::iterator                      mTextMapIterator;
        std::map<std::string, std::vector<Array2dVec3UInt8*> >::iterator        mImageMapIterator;

        uint maxRows = 0;
        for(mIntMapIterator = mIntMap.begin(); mIntMapIterator != mIntMap.end(); ++mIntMapIterator )
            if(mIntMapIterator->second.size() > maxRows)
                maxRows = mIntMapIterator->second.size();
        for(mDoubleMapIterator = mDoubleMap.begin(); mDoubleMapIterator != mDoubleMap.end(); ++mDoubleMapIterator )
            if(mDoubleMapIterator->second.size() > maxRows)
                maxRows = mDoubleMapIterator->second.size();
        for(mTextMapIterator = mTextMap.begin(); mTextMapIterator != mTextMap.end(); ++mTextMapIterator )
            if(mTextMapIterator->second.size() > maxRows)
                maxRows = mTextMapIterator->second.size();
        for(mImageMapIterator = mImageMap.begin(); mImageMapIterator != mImageMap.end(); ++mImageMapIterator )
            if(mImageMapIterator->second.size() > maxRows)
                maxRows = mImageMapIterator->second.size();

        return mTotalRows = maxRows;
    }

    /* get individual row characteristics ************************/
    String GetTextDataByID(String column, int row)
    {
        if(mTextMap.count(column)&& row < mTextMap[column].size())
                return mTextMap[column][row];
        if(mIntMap.count(column) && row < mIntMap[column].size())
                return MakeString(mIntMap[column][row]);
        if(mDoubleMap.count(column) && row < mDoubleMap[column].size())
                return MakeString(mDoubleMap[column][row]);
        return "";
    }

    int GetIntDataByID(String column, int row)
    {
        return mIntMap[column][row];
    }

    double GetDoubleDataByID(String column, int row)
    {
        return mDoubleMap[column][row];
    }

    // Move to TableDataSource.h?
    double GetNormalizedDataByID(String column, int row)
    {
        return GetDoubleDataByID(column, row);
    }

    Array2dVec3UInt8* GetImageDataByID(String column, int row)
    {
        return mImageMap[column][row];
    }

    void AddStaticColumn(String name, int coltype) {
                TableDataSource::AddStaticColumn(name, coltype);
    }
    void AddColumn(String name, int coltype) {
        TableDataSource::AddColumn(name, coltype);
    }

    void AddTextData(String column, String data) {
        mTextMap[column].push_back(data);
        DoUpdateRowsEvent();
    }

    void AddImageData(String column, Array2dVec3UInt8* data) {
        mImageMap[column].push_back(data);
        DoUpdateRowsEvent();
    }

    void AddIntData(String column, int data) {
        mIntMap[column].push_back(data);
        DoUpdateRowsEvent();
    }

    void AddDoubleData(String column, double data) {
        mDoubleMap[column].push_back(data);
        DoUpdateRowsEvent();
    }

private:

    void Init()
    {
        AddTableDataSourceListener(this);
        mTotalRows = -1;
    }

    void UpdateRowsEvent() {
        mTotalRows = -1;
    }

    int mTotalRows;

    std::map<std::string, std::vector<int> >                            mIntMap;
    std::map<std::string, std::vector<double> >                         mDoubleMap;
    std::map<std::string, std::vector<std::string> >            mTextMap;
    std::map<std::string, std::vector<Array2dVec3UInt8*> >      mImageMap;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(WritableTableDataSource, Application.MediaTable);

} // namespace MediaTable
} // namespace Application
} // namespace Impala

#endif // WritableTableDataSource_h

---