C++ Table::addRow方法代码示例

  void fillTable( const std::vector<Path>& items )
  {
    unsigned int columnCount = table->width() / 150;
    table->setRowHeight( 150 );

    if( items.size() < columnCount )
      columnCount = items.size();

    for( unsigned int k=0; k < columnCount; k++ )
    {
      table->addColumn( "" );
      table->setColumnWidth( table->columnCount()-1, 150 );
    }

    for( unsigned int k=0; k < items.size(); k++ )
    {
      int rowNumber = k / columnCount;
      int columnNumber = k % columnCount;
      if( rowNumber >= table->rowCount() )
      {
        table->addRow( rowNumber );
      }

      Path picPath = items[ k ];
      if( available.contains( picPath.extension() ) )
      {
        picPath = picPath.changeExtension( "png" );
      }

      Picture pic = PictureLoader::instance().load( vfs::NFile::open( picPath ) );
      Image* image = new Image( table, Rect( 0, 0, 140, 140 ), pic, Image::best );
      table->addElementToCell( rowNumber, columnNumber, image );
      table->setCellData( rowNumber, columnNumber, "path", items[ k ].toString() );
    }    
  }

XHMM::xhmmInputManager::Table* XHMM::xhmmInputManager::readTable(string tableFile, bool header) {
#if defined(DEBUG)
	cerr << "Reading file " << tableFile << endl << endl;
#endif

	HMM_PP::istreamLineReader* tableStream = HMM_PP::utils::getIstreamLineReaderFromFile(tableFile);
	if (tableStream == NULL || tableStream->eof())
		throw new Exception("Unable to read from (possibly empty) file '" + tableFile + "'");

	Table* table = NULL;
	if (header) {
		Table::Row* columns = readRowFromStream(tableStream);
		table = new Table(columns);
	}
	else
		table = new Table();

	while (!tableStream->eof()) {
		Table::Row* row = readRowFromStream(tableStream);
		table->addRow(row);
	}

	delete tableStream;

	return table;
}

void FillerBase::setTcal2(const String& tcaltime,
                          const Vector<Float>& tcal)
{
  uInt id = 0 ;
  Table tab = table_->tcal().table() ;
  Table result =
    //tab( nelements(tab.col("TCAL")) == uInt (tcal.size()) && 
    //     all(tab.col("TCAL")== tcal) &&
    //     tab.col("TIME") == tcaltime, 1 ) ;
    tab( nelements(tab.col("TCAL")) == uInt (tcal.size()) && 
         all(tab.col("TCAL")== tcal), 1 ) ;

  if ( result.nrow() > 0 ) {
    ROTableColumn tmpCol( result, "ID" ) ;
    tmpCol.getScalar( 0, id ) ;
  }
  else {
    uInt rno = tab.nrow();
    tab.addRow();
    TableColumn idCol( tab, "ID" ) ;
    TableColumn tctimeCol( tab, "TIME" ) ;
    ArrayColumn<Float> tcalCol( tab, "TCAL" ) ;
    // get last assigned _id and increment
    if ( rno > 0 ) {
      idCol.getScalar(rno-1, id);
      id++;
    }
    tctimeCol.putScalar(rno, tcaltime);
    tcalCol.put(rno, tcal);
    idCol.putScalar(rno, id);
  }

  RecordFieldPtr<uInt> mcalidCol(row_.record(), "TCAL_ID");
  *mcalidCol = id;
}

/*
 * rel table :
 * ROW[0] = TOT_T
 * ROW[1] = NREC_T
 * ROW[2] = REC_T
 * ROW[3] = COPY_T
 * ROW[4] = TUPLES
 * ROW[5] = REL NAME
 * ROW[6] = ID
 * ROW[7] = SRC
 * ROW[8] = PERFOR
 *
 */
Table OutputProcessor::getRelTable() {
    std::unordered_map<std::string, std::shared_ptr<Relation>>& relation_map = programRun->getRelation_map();
    Table table;
    for (auto& rel : relation_map) {
        std::shared_ptr<Relation> r = rel.second;
        Row row(9);
        double total_time = r->getNonRecTime() + r->getRecTime() + r->getCopyTime();
        row[0] = std::shared_ptr<CellInterface>(new Cell<double>(total_time));
        row[1] = std::shared_ptr<CellInterface>(new Cell<double>(r->getNonRecTime()));
        row[2] = std::shared_ptr<CellInterface>(new Cell<double>(r->getRecTime()));
        row[3] = std::shared_ptr<CellInterface>(new Cell<double>(r->getCopyTime()));
        row[4] = std::shared_ptr<CellInterface>(new Cell<long>(r->getNum_tuplesRel()));
        row[5] = std::shared_ptr<CellInterface>(new Cell<std::string>(r->getName()));
        row[6] = std::shared_ptr<CellInterface>(new Cell<std::string>(r->getId()));
        row[7] = std::shared_ptr<CellInterface>(new Cell<std::string>(r->getLocator()));
        if (total_time != 0.0) {
            row[8] = std::shared_ptr<CellInterface>(new Cell<double>(r->getNum_tuplesRel() / total_time));
        } else {
            row[8] = std::shared_ptr<CellInterface>(new Cell<double>(r->getNum_tuplesRel() / 1.0));
        }

        table.addRow(std::make_shared<Row>(row));
    }
    return table;
}

int main(int argc, char const *argv[])
{
	DecisonMakingTree tree;
	Table table;
	vector<string> v1  {"qingnian", "1", "1", "1", "1"};
	vector<string> v2  {"qingnian", "1", "1", "2", "1"};
	vector<string> v3  {"qingnian", "2", "1", "2", "2"};
	vector<string> v4  {"qingnian", "2", "2", "1", "2"};
	vector<string> v5  {"qingnian", "1", "1", "1", "1"};
	vector<string> v6  {"zhongnian", "1", "1", "1", "1"};
	vector<string> v7  {"zhongnian", "1", "1", "2", "1"};
	vector<string> v8  {"zhongnian", "2", "2", "2", "2"};
	vector<string> v9  {"zhongnian", "1", "2", "3", "2"};
	vector<string> v10 {"zhongnian", "1", "2", "3", "2"};
	vector<string> v11 {"laonian", "1", "2", "3", "2"};
	vector<string> v12 {"laonian", "1", "2", "2", "2"};
	vector<string> v13 {"laonian", "2", "1", "2", "2"};
	vector<string> v14 {"laonian", "2", "1", "3", "2"};
	vector<string> v15 {"laonian", "1", "1", "1", "1"};

	table.addRow(Row(v1 ));
	table.addRow(Row(v2 ));
	table.addRow(Row(v3 ));
	table.addRow(Row(v4 ));
	table.addRow(Row(v5 ));
	table.addRow(Row(v6 ));
	table.addRow(Row(v7 ));
	table.addRow(Row(v8 ));
	table.addRow(Row(v9 ));
	table.addRow(Row(v10));
	table.addRow(Row(v11));
	table.addRow(Row(v12));
	table.addRow(Row(v13));
	table.addRow(Row(v14));
	table.addRow(Row(v15));

	cout << "----- tree with ID3 -------" << endl;
	tree.initTree(table, 4);
	tree.decisionMakingTreeID3();
	// tree.printTree();

	cout << "----- tree with C45 -------" << endl;
	tree.initTree(table, 4);
	tree.decisionMakingTreeC45();
	// tree.printTree();


	return 0;
}

bool Problem::isSatisfiable() const {
	Table table;
	table.empty();
	table.addRow();
	table.addColumn(ProblemConstants::cResultColumnName);
	table.setField(table.getCurrentRow(), ProblemConstants::cResultColumnName, 0);
	
	for (unsigned int i = 0; i < _variables.size(); i++) {
		table.addColumn(_variables[i].toString());
		table.setField(table.getCurrentRow(), _variables[i].toString(), -1);
	}

	return simSat(table, 0);
}

/*
 Add a row to the table given the column names and data for the rows
*/
void Database::addRowToTable(string tableName, vector<string> columnNames,
		vector<string> rowData) {

	if (columnNames.size() != rowData.size()) {
		throw DatabaseException(12);
	}

	Table *theTable = findTable(tableName);

	if (theTable == NULL) {
		throw DatabaseException(10, tableName + " does not exist.");
	}

	theTable->addRow(columnNames, rowData);
}

void InvokeCommand::fillTableArg(Table & tableArg, const mArray &tableArray) {
    for (mArray::const_iterator i = tableArray.begin(); i != tableArray.end(); ++i) {
        const mArray rowArray = i->get_array();
        if (i == tableArray.begin()) { // the first row are the columns
            for (mArray::const_iterator j = rowArray.begin(); j != rowArray.end(); ++j) {
                tableArg.addColumn(j->get_str());
            }
        } else {
            Table::row_type row;
            for (mArray::const_iterator j = rowArray.begin(); j != rowArray.end(); ++j) {
                row.push_back(j->get_str());
            }
            tableArg.addRow(row);
        }
    }
}

void oDBRunnerEntry::addTableRow(Table &table) const {
  bool canEdit = !oe->isClient();

  oDBRunnerEntry &it = *(oDBRunnerEntry *)(this);
  table.addRow(index+1, &it);
  if (!db)
    throw meosException("Not initialized");

  RunnerDBEntry &r = db->rdb[index];
  int row = 0;
  table.set(row++, it, TID_INDEX, itos(index+1), false, cellEdit);

  table.set(row++, it, TID_ID, itos(r.extId), false, cellEdit);
  table.set(row++, it, TID_NAME, r.name, canEdit, cellEdit);

  const pClub pc = db->getClub(r.clubNo);
  if (pc)
    table.set(row++, it, TID_CLUB, pc->getName(), canEdit, cellSelection);
  else
    table.set(row++, it, TID_CLUB, "", canEdit, cellSelection);

  table.set(row++, it, TID_CARD, r.cardNo > 0 ? itos(r.cardNo) : "", canEdit, cellEdit);
  char nat[4] = {r.national[0],r.national[1],r.national[2], 0};

  table.set(row++, it, TID_NATIONAL, nat, canEdit, cellEdit);
  char sex[2] = {r.sex, 0};
  table.set(row++, it, TID_SEX, sex, canEdit, cellEdit);
  table.set(row++, it, TID_YEAR, itos(r.birthYear), canEdit, cellEdit);

  oClass *val = 0;
  bool found = false;

  if (r.extId < unsigned(-1))
    found = db->runnerInEvent.lookup(int(r.extId), val);

  if (canEdit)
    table.setTableProp(Table::CAN_DELETE|Table::CAN_INSERT|Table::CAN_PASTE);
  else
    table.setTableProp(0);

  if (!found)
    table.set(row++, it, TID_ENTER, "@+", false, cellAction);
  else
    table.set(row++, it, TID_ENTER, val ? val->getName() : "", false, cellEdit);
}

void oClub::addTableRow(Table &table) const {
  table.addRow(getTableId(), pClass(this));

  bool dbClub = table.getInternalName() != TB_CLUBS;
  bool canEdit =  dbClub ? !oe->isClient() : true;

  pClub it = pClub(this);
  int row = 0;
  table.set(row++, *it, TID_ID, itos(getId()), false);
  table.set(row++, *it, TID_MODIFIED, getTimeStamp(), false);

  table.set(row++, *it, TID_CLUB, getName(), canEdit);
  row = oe->oClubData->fillTableCol(*this, table, canEdit);

  if (!dbClub) {
    table.set(row++, *it, TID_NUM, itos(tNumRunners), false);
    table.set(row++, *it, TID_FEE, oe->formatCurrency(tFee), false);
    table.set(row++, *it, TID_PAID, oe->formatCurrency(tPaid), false);
  }
}

    std::ostream &
        Dashboard::print(std::ostream & os) {
            Table myTable;
            myTable.addColumn("timername","Timer Name",Table::JUSTIFIED_LEFT,Table::JUSTIFIED_LEFT);
            myTable.addColumn("elapsed","ms",'.',Table::JUSTIFIED_MIDDLE,4);
            myTable.addColumn("average","avrg.",'.',Table::JUSTIFIED_MIDDLE,4);
            myTable.addColumn("minimum","min.",'.',Table::JUSTIFIED_MIDDLE,4);
            myTable.addColumn("maximum","max.",'.',Table::JUSTIFIED_MIDDLE,4);
            myTable.addColumn("intervals","i",Table::JUSTIFIED_RIGHT);
            myTable.addColumn("persec","i/sec",Table::JUSTIFIED_MIDDLE);
            myTable.addColumn("cycles","cyc.",Table::JUSTIFIED_RIGHT);
            printTimers(myTable);
            myTable.print(os);

            if (!_myCounters.empty()) {
                Table myCounterTable;
                myCounterTable.addColumn("countername","Counter Name",Table::JUSTIFIED_LEFT);
                myCounterTable.addColumn("count","Count",'.');
                myCounterTable.addColumn("cycles","Cycles",Table::JUSTIFIED_MIDDLE);

                for (std::map<std::string,CounterPtr>::iterator it=_myCounters.begin();
                    it != _myCounters.end(); ++it)
                {
                    myCounterTable.addRow();
                    const asl::Counter & myCounter = _myCompleteCycleCounters[it->first];
                    unsigned long myCycleCount = _myGroupCounters[myCounter.getGroup()].getCount();
                    myCounterTable.setField("countername",it->first);
                    if (myCycleCount > 1) {
                        myCounterTable.setField("count",as_string(myCounter.getCount()));
                        // we do not want an averaged counter (vs)
                        //myCounterTable.setField("count",as_string(myCounter.getCount() / myCycleCount ));
                        myCounterTable.setField("cycles",as_string(myCycleCount));
                    } else {
                        myCounterTable.setField("count",as_string(myCounter.getCount()));
                        myCounterTable.setField("cycles","incomplete");
                    }
                }
                myCounterTable.print(os);
            }
            return os;
    }

void
PacketsScene::addPacket (qreal tx, qreal rx, uint32_t fromNodeId, uint32_t toNodeId, QString metaInfo, bool drawPacket)
{
  QString shortMeta = "";
  if (m_filter != AnimPacket::ALL)
    {
      bool result;
      shortMeta = AnimPacket::getMeta (metaInfo, m_filter, result, false);
      if (!result)
        return;
    }
  else
    {
      shortMeta = AnimPacket::getMeta (metaInfo, false);
    }

  QRegExp rex (m_filterRegex);
  if (rex.indexIn (metaInfo) == -1)
  {
    return;
  }

  qreal txY = 0;
  qreal rxY = 0;
  if (drawPacket && m_showGraph)
    {
      qreal fromNodeX = m_interNodeSpacing * m_lineIndex[fromNodeId];
      qreal toNodeX = m_interNodeSpacing * m_lineIndex[toNodeId];
      txY = timeToY (tx);
      rxY = timeToY (rx);

      GraphPacket * graphPacket = new GraphPacket (QPointF (fromNodeX, txY), QPointF (toNodeX, rxY));
      //addItem (graphPacket);
      m_packetPath.moveTo (graphPacket->line ().p1 ());
      m_packetPath.lineTo (graphPacket->line ().p2 ());
      qreal angle = 45;
      qreal mag = 9;
      QPointF endPoint (graphPacket->line ().p2 ());
      if (1)
        {
        if (graphPacket->line ().angle () > 270)
          {
            m_packetPath.moveTo (endPoint);
            angle += graphPacket->line ().angle ();
            //NS_LOG_DEBUG ("Angle:" << graphPacket->line ().angle () << " Final Angle:" << angle);
            m_packetPath.lineTo (endPoint.x () - mag * cos (angle * PI/180), endPoint.y () - mag * sin (angle * PI/180));
            m_packetPath.moveTo (endPoint);
            m_packetPath.lineTo (endPoint.x () - mag * cos (angle * PI/180), endPoint.y () + mag * sin (angle * PI/180));

          }
        else if (graphPacket->line ().angle () > 180)
          {
            m_packetPath.moveTo (endPoint);
            angle += 180 - graphPacket->line ().angle ();
            //NS_LOG_DEBUG ("Angle:" << graphPacket->line ().angle () << " Final Angle:" << angle);
            m_packetPath.lineTo (endPoint.x () + mag * cos (angle * PI/180), endPoint.y () - mag * sin (angle * PI/180));
            m_packetPath.moveTo (endPoint);
            m_packetPath.lineTo (endPoint.x () + mag * cos (angle * PI/180), endPoint.y () + mag * sin (angle * PI/180));
          }
        }

      m_packetPathItem->setPath (m_packetPath);

      m_packetLines.push_back (graphPacket);
      QGraphicsSimpleTextItem * info = new QGraphicsSimpleTextItem (shortMeta);
      addItem (info);
      m_packetInfoTexts.push_back (info);
      info->setFlag (QGraphicsItem::ItemIgnoresTransformations);
      info->setPos (QPointF (fromNodeX, txY));
      qreal textAngle = graphPacket->line().angle ();
      if(textAngle < 90)
        {
          textAngle = 360-textAngle;
        }
      else if (textAngle > 270)
        {
          textAngle = 360-textAngle;
        }
      else
        {
          textAngle = 180-textAngle;
          info->setPos (QPointF (toNodeX, rxY));

        }
      info->rotate (textAngle);
    }

  Table * table = PacketsMode::getInstance ()->getTable ();
  QStringList sl;
  sl << QString::number (fromNodeId)
     << QString::number (toNodeId)
     << QString::number (tx)
     << shortMeta;
  table->addRow (sl);

  if (m_showGrid && drawPacket && m_showGraph)
    {
      QGraphicsSimpleTextItem * txText = new QGraphicsSimpleTextItem (QString::number (tx));
      txText->setFlag (QGraphicsItem::ItemIgnoresTransformations);
      addItem (txText);
//.........这里部分代码省略.........

void FillerBase::setWeather2(Float temperature, 
                             Float pressure,
                             Float humidity,
                             Float windspeed, 
                             Float windaz)
{
  uInt nEntry = wEntry_.size() ;
  Int idx = -1 ;
  Vector<Float> entry( 5 ) ;
  entry[0] = temperature ;
  entry[1] = pressure ;
  entry[2] = humidity ;
  entry[3] = windspeed ;
  entry[4] = windaz ;
  for ( uInt i = 0 ; i < nEntry ; i++ ) {
    if ( allEQ( entry, wEntry_[i] ) ) {
      idx = i ;
      break ;
    }
  }
  uInt id ;
  if ( idx != -1 )
    id = wIdx_[idx] ;
  else {
    Table tab = table_->weather().table() ;
    Table subt = tab( tab.col("TEMPERATURE") == temperature     \
                      && tab.col("PRESSURE") == pressure        \
                      && tab.col("HUMIDITY") == humidity        \
                      && tab.col("WINDSPEED") == windspeed      \
                      && tab.col("WINDAZ") == windaz, 1 ) ;
    Int nrow = tab.nrow() ;
    Int nrowSel = subt.nrow() ;
    if ( nrowSel == 0 ) {
      tab.addRow( 1, True ) ;
      TableRow row( tab ) ;
      TableRecord &rec = row.record() ;
      RecordFieldPtr<casa::uInt> rfpi ;
      rfpi.attachToRecord( rec, "ID" ) ;
      *rfpi = (uInt)nrow ;
      RecordFieldPtr<casa::Float> rfp ;
      rfp.attachToRecord( rec, "TEMPERATURE" ) ;
      *rfp = temperature ;
      rfp.attachToRecord( rec, "PRESSURE" ) ;
      *rfp = pressure ;
      rfp.attachToRecord( rec, "HUMIDITY" ) ;
      *rfp = humidity ;
      rfp.attachToRecord( rec, "WINDSPEED" ) ;
      *rfp = windspeed ;
      rfp.attachToRecord( rec, "WINDAZ" ) ;
      *rfp = windaz ;
      row.put( nrow, rec ) ;
      id = (uInt)nrow ;
    }
    else {
      ROTableColumn tc( subt, "ID" ) ;
      id = tc.asuInt( 0 ) ;
    }
    wEntry_.push_back( entry ) ;
    wIdx_.push_back( id ) ;
  }
  RecordFieldPtr<uInt> mweatheridCol(row_.record(), "WEATHER_ID");
  *mweatheridCol = id;
}

/*
 * rul table :
 * ROW[0] = TOT_T
 * ROW[1] = NREC_T
 * ROW[2] = REC_T
 * ROW[3] = COPY_T
 * ROW[4] = TUPLES
 * ROW[5] = RUL NAME
 * ROW[6] = ID
 * ROW[7] = SRC
 * ROW[8] = PERFOR
 * ROW[9] = VER
 * ROW[10]= REL_NAME
 */
Table OutputProcessor::getRulTable() {
    std::unordered_map<std::string, std::shared_ptr<Relation>>& relation_map = programRun->getRelation_map();
    std::unordered_map<std::string, std::shared_ptr<Row>> rule_map;

    double tot_rec_tup = programRun->getTotNumRecTuples();
    double tot_copy_time = programRun->getTotCopyTime();

    for (auto& rel : relation_map) {
        for (auto& _rul : rel.second->getRuleMap()) {
            Row row(11);
            std::shared_ptr<Rule> rul = _rul.second;
            row[1] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
            row[2] = std::shared_ptr<CellInterface>(new Cell<double>(0.0));
            row[3] = std::shared_ptr<CellInterface>(new Cell<double>(0.0));
            row[4] = std::shared_ptr<CellInterface>(new Cell<long>(rul->getNum_tuples()));
            row[5] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getName()));
            row[6] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getId()));
            row[7] = std::shared_ptr<CellInterface>(new Cell<std::string>(rel.second->getName()));
            row[8] = std::shared_ptr<CellInterface>(new Cell<long>(0));
            row[10] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getLocator()));

            rule_map.emplace(rul->getName(), std::make_shared<Row>(row));
        }
        for (auto& iter : rel.second->getIterations()) {
            for (auto& _rul : iter->getRul_rec()) {
                std::shared_ptr<Rule> rul = _rul.second;
                if (rule_map.find(rul->getName()) != rule_map.end()) {
                    std::shared_ptr<Row> _row = rule_map[rul->getName()];
                    Row row = *_row;
                    row[2] = std::shared_ptr<CellInterface>(
                            new Cell<double>(row[2]->getDoubVal() + rul->getRuntime()));
                    row[4] = std::shared_ptr<CellInterface>(
                            new Cell<long>(row[4]->getLongVal() + rul->getNum_tuples()));
                    row[0] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
                    rule_map[rul->getName()] = std::make_shared<Row>(row);
                } else {
                    Row row(11);
                    row[1] = std::shared_ptr<CellInterface>(new Cell<double>(0.0));
                    row[2] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
                    row[3] = std::shared_ptr<CellInterface>(new Cell<double>(0.0));
                    row[4] = std::shared_ptr<CellInterface>(new Cell<long>(rul->getNum_tuples()));
                    row[5] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getName()));
                    row[6] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getId()));
                    row[7] = std::shared_ptr<CellInterface>(new Cell<std::string>(rel.second->getName()));
                    row[8] = std::shared_ptr<CellInterface>(new Cell<long>(rul->getVersion()));
                    row[0] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
                    rule_map[rul->getName()] = std::make_shared<Row>(row);
                }
            }
        }
        for (auto& _row : rule_map) {
            std::shared_ptr<Row> row = _row.second;
            Row t = *row;
            if (t[6]->getStringVal().at(0) == 'C') {
                double rec_tup = (double)(t[4]->getLongVal());
                t[3] = std::shared_ptr<CellInterface>(
                        new Cell<double>(rec_tup * tot_copy_time / tot_rec_tup));
            }
            double val = t[1]->getDoubVal() + t[2]->getDoubVal() + t[3]->getDoubVal();

            t[0] = std::shared_ptr<CellInterface>(new Cell<double>(val));

            if (t[0]->getDoubVal() != 0.0) {
                t[9] = std::shared_ptr<CellInterface>(
                        new Cell<double>(t[4]->getLongVal() / t[0]->getDoubVal()));
            } else {
                t[9] = std::shared_ptr<CellInterface>(new Cell<double>(t[4]->getLongVal() / 1.0));
            }
            _row.second = std::make_shared<Row>(t);
        }
    }

    Table table;
    for (auto& _row : rule_map) {
        table.addRow(_row.second);
    }
    return table;
}

/*
 * ver table :
 * ROW[0] = TOT_T
 * ROW[1] = NREC_T
 * ROW[2] = REC_T
 * ROW[3] = COPY_T
 * ROW[4] = TUPLES
 * ROW[5] = RUL NAME
 * ROW[6] = ID
 * ROW[7] = SRC
 * ROW[8] = PERFOR
 * ROW[9] = VER
 * ROW[10]= REL_NAME
 */
Table OutputProcessor::getVersions(std::string strRel, std::string strRul) {
    std::unordered_map<std::string, std::shared_ptr<Relation>>& relation_map = programRun->getRelation_map();
    std::unordered_map<std::string, std::shared_ptr<Row>> rule_map;

    double tot_rec_tup = programRun->getTotNumRecTuples();
    double tot_copy_time = programRun->getTotCopyTime();

    for (auto& _rel : relation_map) {
        std::shared_ptr<Relation> rel = _rel.second;
        if (rel->getId().compare(strRel) == 0) {
            for (auto& iter : rel->getIterations()) {
                for (auto& _rul : iter->getRul_rec()) {
                    std::shared_ptr<Rule> rul = _rul.second;
                    if (rul->getId().compare(strRul) == 0) {
                        std::string strTemp =
                                rul->getName() + rul->getLocator() + std::to_string(rul->getVersion());

                        if (rule_map.find(strTemp) != rule_map.end()) {
                            std::shared_ptr<Row> _row = rule_map[strTemp];
                            Row row = *_row;
                            row[2] = std::shared_ptr<CellInterface>(
                                    new Cell<double>(row[2]->getDoubVal() + rul->getRuntime()));
                            row[4] = std::shared_ptr<CellInterface>(
                                    new Cell<long>(row[4]->getLongVal() + rul->getNum_tuples()));
                            row[0] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
                            rule_map[strTemp] = std::make_shared<Row>(row);
                        } else {
                            Row row(10);
                            row[1] = std::shared_ptr<CellInterface>(new Cell<double>(0.0));
                            row[2] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
                            row[4] = std::shared_ptr<CellInterface>(new Cell<long>(rul->getNum_tuples()));
                            row[5] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getName()));
                            row[6] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getId()));
                            row[7] = std::shared_ptr<CellInterface>(new Cell<std::string>(rel->getName()));
                            row[8] = std::shared_ptr<CellInterface>(new Cell<long>(rul->getVersion()));
                            row[9] = std::shared_ptr<CellInterface>(new Cell<std::string>(rul->getLocator()));
                            row[0] = std::shared_ptr<CellInterface>(new Cell<double>(rul->getRuntime()));
                            rule_map[strTemp] = std::make_shared<Row>(row);
                        }
                    }
                }
            }
            for (auto row : rule_map) {
                Row t = *row.second;
                double d = tot_rec_tup;
                long d2 = t[4]->getLongVal();
                t[3] = std::shared_ptr<CellInterface>(new Cell<double>(d2 * tot_copy_time / d));
                t[0] = std::shared_ptr<CellInterface>(
                        new Cell<double>(t[1]->getDoubVal() + t[2]->getDoubVal() + t[3]->getDoubVal()));
                rule_map[row.first] = std::make_shared<Row>(t);
            }
            break;
        }
    }

    Table table;
    for (auto& _row : rule_map) {
        table.addRow(_row.second);
    }
    return table;
}