00001 #ifndef Impala_Core_Table_SimilarityTableSet_h
00002 #define Impala_Core_Table_SimilarityTableSet_h
00003
00004 #include <vector>
00005 #include "Util/DatabaseReadString.h"
00006 #include "Util/DatabaseWriteString.h"
00007 #include "Basis/NativeTypes.h"
00008 #include "Core/Column/GenerateId.h"
00009 #include "Core/Column/Sort.h"
00010 #include "Core/Column/Find.h"
00011 #include "Core/Table/TableTem.h"
00012 #include "Core/Table/Copy.h"
00013 #include "Core/Table/Read.h"
00014 #include "Core/Table/Write.h"
00015 #include "Core/Table/Append.h"
00016 #include "Core/Table/QuidTable.h"
00017 #include "Core/Table/ScoreTable.h"
00018 #include "Core/Table/Equals.h"
00019 #include "Core/ImageSet/ImageSet.h"
00020 #include "Core/VideoSet/VideoSet.h"
00021
00022 namespace Impala
00023 {
00024 namespace Core
00025 {
00026 namespace Table
00027 {
00028
00029
00036 class SimilarityTableSet
00037 {
00038 public:
00039
00040 typedef TableTem<Column::ColumnTem<Real64> > SimTableType;
00041 typedef TableTem<Column::ColumnTem<Quid> > RankTableType;
00042
00043 SimilarityTableSet(std::vector<String> names, int tableSize)
00044 {
00045 mQuids = new QuidTable(tableSize);
00046 mQuids->SetColName(1, "quid");
00047 for (size_t i=0 ; i<names.size() ; i++)
00048 {
00049 AddTable(names[i]);
00050 }
00051 }
00052
00053 virtual
00054 ~SimilarityTableSet()
00055 {
00056 delete mQuids;
00057 for (size_t i=0 ; i<mSims.size() ; i++)
00058 delete mSims[i];
00059 for (size_t i=0 ; i<mRanks.size() ; i++)
00060 delete mRanks[i];
00061 }
00062
00063 #ifndef REPOSITORY_USED // Here comes the deprecated stuff
00064 static SimilarityTableSet*
00065 MakeFromFile(VideoSet::VideoSet* videoSet, String conceptSet, String model,
00066 String feature)
00067 {
00068 String path = videoSet->GetFilePathSimilarityIndex(conceptSet, model,
00069 feature, "names.txt",
00070 false, false);
00071 if (path.empty())
00072 return 0;
00073 return MakeFromFile(path, videoSet->GetDatabase());
00074 }
00075
00076 static SimilarityTableSet*
00077 MakeFromFile(Database::RawDataSet* dataSet, String walkType, String conceptSet,
00078 String model, String featureString, int fileOrDirId)
00079 {
00080 String path =
00081 dataSet->GetFilePathSimilarityData(walkType, conceptSet, model,
00082 featureString, fileOrDirId,
00083 "names.txt", false, false);
00084 if (path.empty())
00085 return 0;
00086 return MakeFromFile(path, dataSet->GetDatabase());
00087 }
00088
00089
00090 static SimilarityTableSet*
00091 MakeFromFile(ImageSet::ImageSet* is, String conceptSet, String model,
00092 String featureString)
00093 {
00094 String path =
00095 is->GetFilePathSimilarityIndex(conceptSet, model, featureString,
00096 "names.txt", false, false);
00097 if (path.empty())
00098 return 0;
00099 return MakeFromFile(path, is->GetDatabase());
00100 }
00101
00102 static SimilarityTableSet*
00103 MakeFromFile(String path, Util::Database* db)
00104 {
00105 std::vector<String> names;
00106 Util::DatabaseReadString(std::back_inserter(names), path, db, true);
00107 SimilarityTableSet* res = new SimilarityTableSet(names, 0);
00108 path.resize(path.size() - 9);
00109 if (path.size() == 0)
00110 path = "./";
00111 res->Load(path, db);
00112 path.resize(path.size() - 1);
00113 String dir = FileNameTail(path);
00114 res->SetDescription(dir);
00115 return res;
00116 }
00117
00118 static bool
00119 Exists(Database::RawDataSet* dataSet, String walkType, String conceptSet,
00120 String model, String featureString, int fileId)
00121 {
00122 String path =
00123 dataSet->GetFilePathSimilarityData(walkType, conceptSet, model,
00124 featureString, fileId,
00125 "names.txt", false, true);
00126 return !path.empty();
00127 }
00128
00129 #endif // REPOSITORY_USED
00130
00131 String
00132 GetDescription()
00133 {
00134 return mDescription;
00135 }
00136
00137 void
00138 SetDescription(String description)
00139 {
00140 mDescription = description;
00141 }
00142
00143 int
00144 NrTables() const
00145 {
00146 return mNames.size();
00147 }
00148
00149 int
00150 TableSize() const
00151 {
00152 return mQuids->Size();
00153 }
00154
00155 std::vector<String>
00156 GetNames()
00157 {
00158 return mNames;
00159 }
00160
00161 String
00162 GetName(int id) const
00163 {
00164 return mNames[id];
00165 }
00166
00167 int
00168 GetIndex(String name)
00169 {
00170 for (int i=0 ; i<mNames.size() ; i++)
00171 if (mNames[i] == name)
00172 return i;
00173 return -1;
00174 }
00175
00176 void
00177 Rename(int id, String name)
00178 {
00179 mNames[id] = name;
00180 }
00181
00182 int
00183 GetQuidClass() const
00184 {
00185 if (mQuids->Size() < 1)
00186 return QUID_CLASS_UNKNOWN;
00187 return QuidClass(mQuids->Get1(0));
00188 }
00189
00190 QuidTable*
00191 GetQuidTable() const
00192 {
00193 return mQuids;
00194 }
00195
00196 int
00197 FindQuid(Quid quid)
00198 {
00199 return Column::Find(mQuids->GetColumn1(), quid);
00200 }
00201
00202 void
00203 ChangeQuidObject(int newObject)
00204 {
00205 int nrChanged = 0;
00206 for (int i=0 ; i<mQuids->Size() ; i++)
00207 {
00208 Quid q = mQuids->Get1(i);
00209 if (QuidObject(q) != newObject)
00210 {
00211 q = QuidObjectChange(q, newObject);
00212 mQuids->Set1(i, q);
00213 nrChanged++;
00214 }
00215 }
00216 if (nrChanged != 0)
00217 ILOG_INFO("Changed " << nrChanged << " quid objects");
00218 }
00219
00220 SimTableType*
00221 GetSimTable(int id) const
00222 {
00223 return mSims[id];
00224 }
00225
00226 void
00227 SetSimTable(int id, ScoreTable* scores)
00228 {
00229 ILOG_INFO("score table size = " << scores->Size());
00230 if(scores->Size() != mQuids->Size())
00231 {
00232 ILOG_ERROR("SetSimTable: size of quids and ScoreTable do not match");
00233 scores->GetQuidTable()->Dump(0, 0, -1);
00234 mQuids->Dump(0, 0, -1);
00235 exit(1);
00236 }
00237 SimTableType* dst = mSims[id];
00238 dst->SetSize(scores->Size());
00239 Copy(dst->GetColumn1(), scores->GetColumn2(), scores->Size());
00240 }
00241
00242 SimTableType*
00243 GetSimTable(String name) const
00244 {
00245 for (size_t i=0 ; i<mNames.size() ; i++)
00246 {
00247 if (mNames[i] == name)
00248 return mSims[i];
00249 }
00250 return 0;
00251 }
00252
00253 RankTableType*
00254 GetRankTable(int id) const
00255 {
00256 return mRanks[id];
00257 }
00258
00259 RankTableType*
00260 GetRankTable(String name) const
00261 {
00262 for (size_t i=0 ; i<mNames.size() ; i++)
00263 {
00264 if (mNames[i] == name)
00265 return mRanks[i];
00266 }
00267 return 0;
00268 }
00269
00270 void
00271 ComputeRank(int tableIdx, bool descending)
00272 {
00273 SimTableType* simTable = mSims[tableIdx];
00274 int size = simTable->Size();
00275 if (size != mQuids->Size())
00276 ILOG_ERROR("ComputeRank: tables sizes do not match: " << size <<
00277 " " << mQuids->Size());
00278 SimTableType* tmp = new SimTableType(size);
00279 Core::Table::Copy(tmp, simTable);
00280 Core::Table::Copy(mRanks[tableIdx], mQuids);
00281 if (descending)
00282 Column::SortDescending(mRanks[tableIdx]->GetColumn1(),
00283 tmp->GetColumn1(), tmp->Size());
00284 else
00285 Column::SortAscending(mRanks[tableIdx]->GetColumn1(),
00286 tmp->GetColumn1(), tmp->Size());
00287 delete tmp;
00288 }
00289
00290 void
00291 ComputeRanks(bool descending)
00292 {
00293 SimTableType* tmp = new SimTableType(mQuids->Size());
00294 for (int i=0 ; i<NrTables() ; i++)
00295 {
00296 ILOG_DEBUG("Sorting table " << i << " of " << NrTables());
00297 if (mSims[i]->Size() != mQuids->Size())
00298 {
00299 ILOG_ERROR("ComputeRanks: tables sizes do not match: " <<
00300 mSims[i]->Size() << " " << mQuids->Size());
00301 continue;
00302 }
00303 Core::Table::Copy(mRanks[i], mQuids);
00304 Core::Table::Copy(tmp, mSims[i]);
00305 if (descending)
00306 Column::SortDescending(mRanks[i]->GetColumn1(),
00307 tmp->GetColumn1(), tmp->Size());
00308 else
00309 Column::SortAscending(mRanks[i]->GetColumn1(),
00310 tmp->GetColumn1(), tmp->Size());
00311 }
00312 delete tmp;
00313 }
00314
00315 void
00316 ComputeRanksTopN(int topN, bool descending)
00317 {
00318 if (mQuids->Size() < topN)
00319 {
00320 ILOG_ERROR("ComputeRanksTopN: not enough quids for top " << topN);
00321 return;
00322 }
00323 if (mRanks[0]->Capacity() != topN)
00324 {
00325 for (int i=0 ; i<NrTables() ; i++)
00326 {
00327 mRanks[i]->Reserve(topN, false);
00328 mRanks[i]->SetSize(topN);
00329 }
00330 }
00331 Column::ColumnTem<Real64>* tmp = new Column::ColumnTem<Real64>(topN);
00332 for (int i=0 ; i<NrTables() ; i++)
00333 {
00334 if (descending)
00335 Column::SortDescendingTopN(mQuids->GetColumn1(),
00336 mSims[i]->GetColumn1(),
00337 mRanks[i]->GetColumn1(), tmp);
00338 else
00339 Column::SortAscendingTopN(mQuids->GetColumn1(),
00340 mSims[i]->GetColumn1(),
00341 mRanks[i]->GetColumn1(), tmp);
00342 }
00343 delete tmp;
00344 }
00345
00346 void
00347 Append(SimilarityTableSet* simSet)
00348 {
00349 if (NrTables() != simSet->NrTables())
00350 {
00351 ILOG_ERROR("Append: different number of tables");
00352 return;
00353 }
00354 Core::Table::Append(GetQuidTable(), simSet->GetQuidTable());
00355 for (int i=0 ; i<NrTables() ; i++)
00356 {
00357 Core::Table::Append(GetSimTable(i), simSet->GetSimTable(i));
00358 }
00359 }
00360
00361 void
00362 Merge(SimilarityTableSet* arg)
00363 {
00364 if (mQuids->Diff(arg->GetQuidTable()) != 0)
00365 {
00366 ILOG_ERROR("Merge: different quids so cannot merge");
00367 return;
00368 }
00369 for (int i=0 ; i<arg->NrTables() ; i++)
00370 {
00371 String name = arg->GetName(i);
00372 int idx = GetIndex(name);
00373 while (idx != -1)
00374 {
00375 name = name + "_2";
00376 idx = GetIndex(name);
00377 }
00378 AddTable(name);
00379 idx = GetIndex(name);
00380 Core::Table::Copy(GetSimTable(idx), arg->GetSimTable(i));
00381 Core::Table::Copy(GetRankTable(idx), arg->GetRankTable(i));
00382 }
00383 }
00384
00385
00386 int
00387 Diff(SimilarityTableSet* arg, bool doDiffRank = false) const
00388 {
00389 if (NrTables() != arg->NrTables())
00390 {
00391 ILOG_ERROR("Diff: NrTables differs: " << NrTables() << " vs "
00392 << arg->NrTables());
00393 return 1;
00394 }
00395 if (TableSize() != arg->TableSize())
00396 {
00397 ILOG_ERROR("Diff: TableSize differs: " << TableSize() << " vs "
00398 << arg->TableSize());
00399 return 1;
00400 }
00401 QuidTable* qTable1 = GetQuidTable();
00402 QuidTable* qTable2 = arg->GetQuidTable();
00403 int qDiff = 0;
00404 for (int i=0 ; i<qTable1->Size() ; i++)
00405 {
00406 if (qTable1->Get1(i) != qTable2->Get1(i))
00407 {
00408 qDiff++;
00409 ILOG_DEBUG("Diff: quid elem " << i << ": "
00410 << qTable1->Get1(i) << " vs " << qTable2->Get1(i));
00411 }
00412 }
00413 if (qDiff > 0)
00414 {
00415 ILOG_ERROR("Diff: " << qDiff << " differences in quid table");
00416 return qDiff;
00417 }
00418
00419 int totalDiff = 0;
00420 for (int t=0 ; t<NrTables() ; t++)
00421 {
00422 int nDiff = 0;
00423 SimTableType* sTable1 = GetSimTable(t);
00424 SimTableType* sTable2 = arg->GetSimTable(t);
00425 for (int i=0 ; i<sTable1->Size() ; i++)
00426 {
00427 if (::fabs(sTable1->Get1(i) - sTable2->Get1(i)) > 0.00001)
00428 {
00429 nDiff++;
00430 ILOG_DEBUG("Diff: sim table " << t << ", elem " << i <<
00431 ": " << sTable1->Get1(i) << " vs " <<
00432 sTable2->Get1(i));
00433 }
00434 }
00435 if (nDiff > 0)
00436 ILOG_ERROR("Diff: " << nDiff << " differences in sim table " <<
00437 GetName(t));
00438 totalDiff += nDiff;
00439
00440 if (!doDiffRank)
00441 continue;
00442
00443 nDiff = 0;
00444 RankTableType* rTable1 = GetRankTable(t);
00445 RankTableType* rTable2 = arg->GetRankTable(t);
00446 for (int i=0 ; i<rTable1->Size() ; i++)
00447 {
00448 if (rTable1->Get1(i) != rTable2->Get1(i))
00449 {
00450 nDiff++;
00451 ILOG_DEBUG("Diff: rank table " << t << ", elem " << i <<
00452 ": " << rTable1->Get1(i) << " vs " <<
00453 rTable2->Get1(i));
00454 }
00455 }
00456 if (nDiff > 0)
00457 ILOG_ERROR("Diff: " << nDiff << " differences in rank table " <<
00458 GetName(t));
00459 totalDiff += nDiff;
00460 }
00461
00462 if (totalDiff > 0)
00463 ILOG_ERROR("Diff: total of " << totalDiff << " differences");
00464 return totalDiff;
00465 }
00466
00467
00468
00469 #ifndef REPOSITORY_USED // Here comes the deprecated stuff
00470 void
00471 Load(CString fileBase, Util::Database* db)
00472 {
00473 LoadQuids(fileBase, db);
00474 LoadSims(fileBase, db);
00475 LoadRanks(fileBase, db);
00476 }
00477
00478 void
00479 LoadQuids(CString fileBase, Util::Database* db)
00480 {
00481 String fName = fileBase + "all_quids.tab";
00482 Core::Table::Read(mQuids, fName, db);
00483 }
00484
00485 void
00486 LoadSim(size_t tableIdx, CString fileBase, Util::Database* db)
00487 {
00488 String fName = fileBase + mNames[tableIdx] + "_sim.tab";
00489 Core::Table::Read(mSims[tableIdx], fName, db);
00490 }
00491
00492 void
00493 LoadSims(CString fileBase, Util::Database* db)
00494 {
00495 for (size_t i=0 ; i<mNames.size() ; i++)
00496 LoadSim(i, fileBase, db);
00497 }
00498
00499 void
00500 LoadRank(size_t tableIdx, CString fileBase, Util::Database* db)
00501 {
00502 String fName = fileBase + mNames[tableIdx] + "_rank.tab";
00503 Core::Table::Read(mRanks[tableIdx], fName, db);
00504 }
00505
00506 void
00507 LoadRanks(CString fileBase, Util::Database* db)
00508 {
00509 for (size_t i=0 ; i<mNames.size() ; i++)
00510 LoadRank(i, fileBase, db);
00511 }
00512
00513 void
00514 Save(int tableIdx, CString fileBase, Util::Database* db, bool binary)
00515 {
00516 SaveQuids(fileBase, db, binary);
00517 SaveSim(tableIdx, fileBase, db, binary);
00518 SaveRank(tableIdx, fileBase, db, binary);
00519 }
00520
00521 void
00522 Save(Database::RawDataSet* dataSet, CString conceptSet, CString model,
00523 CString feature, bool binary)
00524 {
00525 String path = dataSet->GetFilePathSimilarityIndex(conceptSet, model,
00526 feature, "names.txt",
00527 true, false);
00528 if (path.empty())
00529 return;
00530 path.resize(path.size() - 9);
00531 Save(path, dataSet->GetDatabase(), binary);
00532 }
00533
00534 void
00535 Save(Database::RawDataSet* dataSet, String walkType, String conceptSet,
00536 CString model, CString feature, int fileOrDirId, bool binary)
00537 {
00538 String path = dataSet->GetFilePathSimilarityData
00539 (walkType, conceptSet, model, feature, fileOrDirId, "names.txt",
00540 true, false);
00541 if (path.empty())
00542 return;
00543 path.resize(path.size() - 9);
00544 Save(path, dataSet->GetDatabase(), binary);
00545 }
00546
00547 void
00548 Save(CString fileBase, Util::Database* db, bool binary)
00549 {
00550 SaveNames(fileBase, db);
00551 SaveQuids(fileBase, db, binary);
00552 SaveSims(fileBase, db, binary);
00553 SaveRanks(fileBase, db, binary);
00554 }
00555
00556 void
00557 SaveNames(CString fileBase, Util::Database* db)
00558 {
00559 String fName = fileBase + "names.txt";
00560 Util::DatabaseWriteString(fName, db, mNames.begin(), mNames.end());
00561 }
00562
00563 void
00564 SaveQuids(CString fileBase, Util::Database* db, bool binary)
00565 {
00566 String fName = fileBase + "all_quids.tab";
00567 Core::Table::Write(mQuids, fName, db, binary);
00568 }
00569
00570 void
00571 SaveSim(size_t tableIdx, CString fileBase, Util::Database* db, bool binary)
00572 {
00573 String fName = fileBase + mNames[tableIdx] + "_sim.tab";
00574 Core::Table::Write(mSims[tableIdx], fName, db, binary);
00575 }
00576
00577 void
00578 SaveSims(CString fileBase, Util::Database* db, bool binary)
00579 {
00580 for (size_t i=0 ; i<mNames.size() ; i++)
00581 SaveSim(i, fileBase, db, binary);
00582 }
00583
00584 void
00585 SaveRank(size_t tableIdx, CString fileBase, Util::Database* db, bool binary)
00586 {
00587 String fName = fileBase + mNames[tableIdx] + "_rank.tab";
00588 Core::Table::Write(mRanks[tableIdx], fName, db, binary);
00589 }
00590
00591 void
00592 SaveRanks(CString fileBase, Util::Database* db, bool binary)
00593 {
00594 for (size_t i=0 ; i<mNames.size() ; i++)
00595 SaveRank(i, fileBase, db, binary);
00596 }
00597 #endif // REPOSITORY_USED
00598
00599
00600
00601 void
00602 Dump(bool doTable)
00603 {
00604 std::cout << "SimilarityTableSet " << GetDescription() << std::endl;
00605 for (int i=0 ; i<NrTables() ; i++)
00606 {
00607 std::cout << "table " << i << ", name = " << GetName(i) << std::endl;
00608 if (doTable)
00609 GetSimTable(i)->Dump();
00610 }
00611 }
00612
00613 void
00614 DumpRanking(int from = 0, int to = -1)
00615 {
00616 DumpRanking(0, from, to);
00617 }
00618
00619 virtual void
00620 DumpRanking(Database::RawDataSet* set, int from = 0, int to = -1)
00621 {
00622 if (to == -1 || to > TableSize())
00623 to = TableSize();
00624 if (to < from)
00625 to = from;
00626 std::cout << "SimilarityTableSet " << GetDescription() << std::endl;
00627 for (int t=0 ; t<NrTables() ; t++)
00628 {
00629 SimTableType* simTable = GetSimTable(t);
00630 RankTableType* rankTable = GetRankTable(t);
00631 std::cout << "table " << t << ", name = " << GetName(t) << std::endl;
00632 if (simTable->Size() != mQuids->Size())
00633 {
00634 ILOG_ERROR("DumpRanking: simtable size doesn't match");
00635 continue;
00636 }
00637 if (rankTable->Size() != mQuids->Size())
00638 {
00639 ILOG_ERROR("DumpRanking: ranktable size doesn't match");
00640 continue;
00641 }
00642 std::cout << "i, Quid, similarity, rank, sim_at_rank" << std::endl;
00643 for (int i=from ; i<to ; i++)
00644 {
00645 Quid quid = mQuids->Get1(i);
00646 std::cout << i << ", ";
00647 if (set && (quid != 0))
00648 std::cout << set->QuidToString(quid, true) << ", ";
00649 else
00650 std::cout << QuidObj(quid) << ", ";
00651 std::cout << simTable->Get1(i) << ", ";
00652 int rank = Find(rankTable->GetColumn1(), quid);
00653 std::cout << rank << ", ";
00654 rank = FindQuid(rankTable->Get1(i));
00655 if ((rank >= 0) && (rank < simTable->Size()))
00656 std::cout << simTable->Get1(rank) << std::endl;
00657 else
00658 std::cout << "<no sim>" << std::endl;
00659 }
00660 std::cout << std::endl;
00661 }
00662 }
00663
00664
00665 void
00666 DumpRankingSorted(Database::RawDataSet* set, Impala::String OutPath, int from = 0, int to = -1)
00667 {
00668 if (to == -1 || to > TableSize())
00669 to = TableSize();
00670 if (to < from)
00671 to = from;
00672 std::cout << "SimilarityTableSet " << GetDescription() << std::endl;
00673 for (int t=0 ; t<NrTables() ; t++)
00674 {
00675 SimTableType* simTable = GetSimTable(t);
00676 RankTableType* rankTable = GetRankTable(t);
00677
00678 if (simTable->Size() != mQuids->Size())
00679 {
00680 ILOG_ERROR("DumpRanking: simtable size doesn't match");
00681 continue;
00682 }
00683 if (rankTable->Size() != mQuids->Size())
00684 {
00685 ILOG_ERROR("DumpRanking: ranktable size doesn't match");
00686 continue;
00687 }
00688
00689 String ListName = OutPath + GetName(t) + ".txt";
00690 FILE* fp = fopen(ListName.c_str(), "wt");
00691
00692 fprintf(fp,"1=rank, 2=position(i), 3=Quid, 4=similarity\n");
00693 for (int i=from ; i<to ; i++)
00694 {
00695
00696 Quid quid = rankTable->Get1(i);
00697 int rank = FindQuid(quid);
00698
00699
00700 String QuidStr;
00701 if (set && (quid != 0))
00702 QuidStr = set->QuidToString(quid, true);
00703 else
00704 QuidStr = QuidObj(quid).ToString();
00705
00706
00707 Real64 sim = simTable->Get1(rank);
00708 fprintf(fp,"%d\t%d\t%s\t%f\n",i, rank, QuidStr.c_str(), sim);
00709
00710
00712
00714
00715
00716
00717
00718 }
00719 fclose(fp);
00720
00721 }
00722 }
00723
00724 void
00725 DumpMatrix(Database::RawDataSet* set, bool dumpQuid)
00726 {
00727 for (int i=0 ; i<TableSize() ; i++)
00728 {
00729 Quid quid = mQuids->Get1(i);
00730 if (dumpQuid)
00731 {
00732 if (set)
00733 std::cout << set->QuidToString(quid, true) << ", ";
00734 else
00735 std::cout << QuidObj(quid) << ", ";
00736 }
00737 for (int t=0 ; t<NrTables() ; t++)
00738 {
00739 SimTableType* simTable = GetSimTable(t);
00740 if ((i == 0) && (simTable->Size() != mQuids->Size()))
00741 {
00742 ILOG_ERROR("DumpMatrix: simtable size doesn't match");
00743 return;
00744 }
00745 std::cout << simTable->Get1(i);
00746 if (t < NrTables() - 1)
00747 std::cout << ", ";
00748 }
00749 std::cout << std::endl;
00750 }
00751 }
00752
00753 private:
00754
00755 void
00756 AddTable(CString name)
00757 {
00758 mNames.push_back(name);
00759 SimTableType* sim = new SimTableType(mQuids->Capacity());
00760 sim->SetColName(1, "similarity");
00761 mSims.push_back(sim);
00762 RankTableType* rank = new RankTableType(mQuids->Capacity());
00763 rank->SetColName(1, "id");
00764 mRanks.push_back(rank);
00765 }
00766
00767 String mDescription;
00768 QuidTable* mQuids;
00769 std::vector<String> mNames;
00770 std::vector<SimTableType*> mSims;
00771 std::vector<RankTableType*> mRanks;
00772
00773 ILOG_VAR_DEC;
00774
00775 };
00776
00777 ILOG_VAR_INIT(SimilarityTableSet, Impala.Core.Table);
00778
00779 }
00780 }
00781 }
00782
00783 #endif