Changing inverted index to deque

querying/src/Computor.cpp

 #include <iostream>
 #include <climits>
+#include <utility>
 #include "Computor.h"
 #include "exceptions/Exceptions.h"
 using namespace std;
-Computor::Computor(Space space, const Query &query) : space(space), query(query) {}
+Computor::Computor(Space space, Query query) : space(std::move(space)), query(std::move(query)) {}
 map<int, double> Computor::compute() {
-    exhaustedIndices = {};
-    auto totalIndices = query.terms.size();
-
-    int lowestDocumentID = nextID();
-    space.forward(lowestDocumentID, query.terms);
     map<int, double> results;
-    while (exhaustedIndices.size() != totalIndices) {
-        results.emplace(lowestDocumentID, computeForDocument(lowestDocumentID));
-        lowestDocumentID = nextID();
-        space.forward(lowestDocumentID, query.terms);
-    }
-
-    return results;
-}
-double Computor::computeForDocument(int ID) {
-    double result = 0;
-    for (const auto &[term, weight]: query.terms) {
-        try {
-            auto d = space.getInvertedIndexByKey(term).getDocumentWeightByID(ID);
-            result += weight * d;
-        }
-
-        catch (EndOfIndexException &e) {
-            exhaustedIndices.emplace(term); //add another exhausted inverted index
-        }
-        catch (IDNotFoundException &e) {
-            continue;
+    availableTerms = query.termsKeyset;
+    while (!availableTerms.empty()) {
+        int ID = nextID(); //get lowest ID
+        double result = 0;
+        for (const auto &term: availableTerms) /*Go through all the remaining terms*/ {
+            try {
+                double queryWeight = query.terms.at(term);
+                double documentWeight = space.getInvertedIndexByKey(term).getDocumentWeightByID(ID);
+                result += documentWeight * queryWeight;
+            }
+            catch (const IDNotFoundException &e) {//inverted index does not contain given ID
+            }
+            catch (const EndOfIndexException &e) {
+                availableTerms.erase(term); //exhaust term
+            }
         }
+        results[ID] = result;
     }
-    return result;
+    return results;
 }
-int Computor::nextID() const {
-    int nextID = INT_MAX;
-    for (const auto &term: query.terms)
-        nextID = min(space[term.first].getLowestID(), nextID);
-
-    return nextID;
+int Computor::nextID() {
+    int lowestID = INT_MAX;
+    for (const auto &queryRecord: query.terms)
+        lowestID = min(space[queryRecord.first].getLowestID(), lowestID);
+    return lowestID;
 }
+

querying/src/Computor.h

@@ -14,15 +14,15 @@ private:
     //Attributes--------------
     Space space;
     const Query query;
-    std::set<std::string> exhaustedIndices;
+    std::set<std::string> availableTerms;
     //Methods-----------------
-    int nextID() const;
+    int nextID();
     double computeForDocument(int ID);
 public:
-    Computor(Space space, const Query &query);
+    Computor(Space space, Query query);
     std::map<int, double> compute();
 };

querying/src/inverted_index/InputParser.cpp

@@ -25,7 +25,7 @@ map<string, InvertedIndex> InputParser::getInvertedIndices() {
         sort(weights.begin(), weights.end(),
              [](const auto &a, const auto &b) { return a.getID() < b.getID(); });
-        invertedIndices.insert({term, InvertedIndex(term, weights)});
+        invertedIndices.emplace(term, InvertedIndex(weights));
     }
     return invertedIndices;

querying/src/inverted_index/InvertedIndex.cpp

@@ -4,16 +4,21 @@
 using namespace std;
-InvertedIndex::InvertedIndex(string term, vector<DocumentWeight> documentWeights)
-        : position(0),
-          term(move(term)),
-          documentWeights(move(documentWeights)) {}
+InvertedIndex::InvertedIndex(deque<DocumentWeight> documentWeights)
+        : documentWeights(move(documentWeights)) {}
+
 double InvertedIndex::getDocumentWeightByID(int ID) {
     if (position + 1 == documentWeights.size())
         throw EndOfIndexException();
+
+    while (documentWeights.front().getID() != ID) {
+        documentWeights.pop_front();
+    }
+    return documentWeights.front().getID();
+
     for (auto it = documentWeights.begin() + position; it != documentWeights.end(); it++) {
         int documentID = (*it).getID();
@@ -21,25 +26,8 @@ double InvertedIndex::getDocumentWeightByID(int ID) {
             throw IDNotFoundException();
         if (documentID == ID) //match!
-        {
-            position = it - documentWeights.begin() + 1; //update position
             return (*it).getWeight();
-        }
-    }
-
-    /*
-
-    for (size_t i = position; position < documentWeights.size(); ++i) {
-        int documentID = documentWeights[i].getWeight();
-
-        if (documentID < ID)
-            throw IDNotFoundException();
-        if (documentID == ID) {
-            position = i + 1;
-            return documentWeights[i];
-        }
     }
-*/
     throw IDNotFoundException();
 }
@@ -49,7 +37,7 @@ const DocumentWeight &InvertedIndex::operator[](size_t i) {
 }
 int InvertedIndex::getLowestID() const {
-    return documentWeights[position].getID();
+    return documentWeights.front().getID();
 }
 void InvertedIndex::forward(int ID) {

querying/src/inverted_index/InvertedIndex.h

@@ -3,7 +3,7 @@
 #include <string>
-#include <vector>
+#include <deque>
 #include "../DocumentWeight.h"
 /**
@@ -14,19 +14,16 @@
 class InvertedIndex {
 private:
     //Attributes-------------
-    size_t position;
-    std::string term;/**<Term identifier */
-    std::vector<DocumentWeight> documentWeights; /**<Inverted index list of documents & their weights in which the term appears */
+    std::deque<DocumentWeight> documentWeights; /**<Inverted index list of documents & their weights in which the term appears */
 public:
     //Methods-----------------
     /**
      * Constructor
-     * @param term Term identifier
      * @param documentWeights Inverted index list of documents in which the term appears, and their weights
      */
-    InvertedIndex(std::string term, std::vector<DocumentWeight> documentWeights);
+    InvertedIndex(std::deque<DocumentWeight> documentWeights);
     /**
      * @brief Finds the @ref DocumentWeight object with a given @ref DocumentWeight::ID in @ref documentWeights
@@ -42,8 +39,6 @@ public:
     int getLowestID() const;
-    void forward(int ID);
-
     const DocumentWeight &operator[](size_t i);
 };

querying/src/space/Query.cpp

@@ -6,5 +6,14 @@
 using namespace std;
-Query::Query(std::map<std::string, double> terms, const double threshold)
-        : terms(std::move(terms)), threshold(threshold) {}
+Query::Query(std::map<std::string, double> terms, double threshold)
+        : terms(std::move(terms)),
+          termsKeyset(getKeyset(terms)),
+          threshold(threshold) {}
+
+set<string> Query::getKeyset(const map<std::string, double> &terms) {
+    set<string> dummy;
+    for (const auto &term: terms)
+        dummy.emplace(term.first);
+    return dummy;
+}

querying/src/space/Query.h

@@ -3,6 +3,7 @@
 #include <map>
+#include <set>
 #include <vector>
 #include <string>
 #include "Space.h"
@@ -14,6 +15,7 @@ class Query {
 public:
     //Attributes-------------
     const std::map<std::string, double> terms; /**<Terms and their weights in the query */
+    const std::set<std::string> termsKeyset; /**<Keyset of terms */
     const double threshold; /**<Acceptable result threshold */
     //Methods----------------
@@ -22,7 +24,9 @@ public:
      * @param terms Terms and their weights in the query
      * @param threshold Acceptable result threshold
      */
-    explicit Query(std::map<std::string, double> terms, const double threshold);
+    explicit Query(std::map<std::string, double> terms, double threshold);
+
+    static std::set<std::string> getKeyset(const std::map<std::string, double> &terms);
 };

querying/src/space/Space.cpp

@@ -17,7 +17,7 @@ InvertedIndex &Space::getInvertedIndexByKey(const string &key) {
     return terms.at(key);
 }
-void Space::forward(int ID, const std::map<std::string, double> q) {
+void Space::forward(int ID, const std::map<std::string, double> &q) {
     for (const auto &term: q)
         terms.at(term.first).forward(ID);
 }

querying/src/space/Space.h

@@ -32,7 +32,7 @@ public:
     const InvertedIndex &operator[](const std::string &key) const;
-    void forward(int ID, const std::map<std::string, double> q);
+    void forward(int ID, const std::map<std::string, double> &q);
 };