From e8926284926e173bb2d666c614fc8f5cceecdbff Mon Sep 17 00:00:00 2001 From: Lukhnos Liu Date: Sat, 19 Feb 2022 10:13:26 -0800 Subject: [PATCH] Remove all the "inFoo" in-param style We don't use out-params in Gramambular, but even for them the best practices have been converging on using "T& param" for required output param and "T* param" for optional output param. At any rate the prefix was never necessary, and hence the removal. --- Source/Engine/Gramambular/Bigram.h | 58 ++++++------- .../Engine/Gramambular/BlockReadingBuilder.h | 21 +++-- Source/Engine/Gramambular/Grid.h | 82 +++++++++---------- Source/Engine/Gramambular/KeyValuePair.h | 24 +++--- Source/Engine/Gramambular/Node.h | 49 ++++++----- Source/Engine/Gramambular/NodeAnchor.h | 49 +++++------ Source/Engine/Gramambular/Span.h | 30 +++---- Source/Engine/Gramambular/Unigram.h | 51 ++++++------ Source/Engine/Gramambular/Walker.h | 14 ++-- 9 files changed, 183 insertions(+), 195 deletions(-) diff --git a/Source/Engine/Gramambular/Bigram.h b/Source/Engine/Gramambular/Bigram.h index caa46de2..1b30fc96 100644 --- a/Source/Engine/Gramambular/Bigram.h +++ b/Source/Engine/Gramambular/Bigram.h @@ -42,53 +42,53 @@ class Bigram { KeyValuePair keyValue; double score; - bool operator==(const Bigram& inAnother) const; - bool operator<(const Bigram& inAnother) const; + bool operator==(const Bigram& another) const; + bool operator<(const Bigram& another) const; }; -inline std::ostream& operator<<(std::ostream& inStream, const Bigram& inGram) { - std::streamsize p = inStream.precision(); - inStream.precision(6); - inStream << "(" << inGram.keyValue << "|" << inGram.preceedingKeyValue << "," - << inGram.score << ")"; - inStream.precision(p); - return inStream; +inline std::ostream& operator<<(std::ostream& stream, const Bigram& gram) { + std::streamsize p = stream.precision(); + stream.precision(6); + stream << "(" << gram.keyValue << "|" << gram.preceedingKeyValue << "," + << gram.score << ")"; + stream.precision(p); + return stream; } -inline std::ostream& operator<<(std::ostream& inStream, - const std::vector& inGrams) { - inStream << "[" << inGrams.size() << "]=>{"; +inline std::ostream& operator<<(std::ostream& stream, + const std::vector& grams) { + stream << "[" << grams.size() << "]=>{"; size_t index = 0; - for (std::vector::const_iterator gi = inGrams.begin(); - gi != inGrams.end(); ++gi, ++index) { - inStream << index << "=>"; - inStream << *gi; - if (gi + 1 != inGrams.end()) { - inStream << ","; + for (std::vector::const_iterator gi = grams.begin(); + gi != grams.end(); ++gi, ++index) { + stream << index << "=>"; + stream << *gi; + if (gi + 1 != grams.end()) { + stream << ","; } } - inStream << "}"; - return inStream; + stream << "}"; + return stream; } inline Bigram::Bigram() : score(0.0) {} -inline bool Bigram::operator==(const Bigram& inAnother) const { - return preceedingKeyValue == inAnother.preceedingKeyValue && - keyValue == inAnother.keyValue && score == inAnother.score; +inline bool Bigram::operator==(const Bigram& another) const { + return preceedingKeyValue == another.preceedingKeyValue && + keyValue == another.keyValue && score == another.score; } -inline bool Bigram::operator<(const Bigram& inAnother) const { - if (preceedingKeyValue < inAnother.preceedingKeyValue) { +inline bool Bigram::operator<(const Bigram& another) const { + if (preceedingKeyValue < another.preceedingKeyValue) { return true; - } else if (preceedingKeyValue == inAnother.preceedingKeyValue) { - if (keyValue < inAnother.keyValue) { + } else if (preceedingKeyValue == another.preceedingKeyValue) { + if (keyValue < another.keyValue) { return true; - } else if (keyValue == inAnother.keyValue) { - return score < inAnother.score; + } else if (keyValue == another.keyValue) { + return score < another.score; } return false; } diff --git a/Source/Engine/Gramambular/BlockReadingBuilder.h b/Source/Engine/Gramambular/BlockReadingBuilder.h index 56c335ca..dac88a12 100644 --- a/Source/Engine/Gramambular/BlockReadingBuilder.h +++ b/Source/Engine/Gramambular/BlockReadingBuilder.h @@ -38,13 +38,13 @@ namespace Gramambular { class BlockReadingBuilder { public: - BlockReadingBuilder(LanguageModel* inLM); + BlockReadingBuilder(LanguageModel* lm); void clear(); size_t length() const; size_t cursorIndex() const; - void setCursorIndex(size_t inNewIndex); - void insertReadingAtCursor(const std::string& inReading); + void setCursorIndex(size_t newIndex); + void insertReadingAtCursor(const std::string& reading); bool deleteReadingBeforeCursor(); // backspace bool deleteReadingAfterCursor(); // delete @@ -64,7 +64,7 @@ class BlockReadingBuilder { std::vector::const_iterator end, const std::string& separator); - //最多使用六個字組成一個詞 + // 最多使用六個字組成一個詞 static const size_t MaximumBuildSpanLength = 6; size_t m_cursorIndex; @@ -75,8 +75,8 @@ class BlockReadingBuilder { std::string m_joinSeparator; }; -inline BlockReadingBuilder::BlockReadingBuilder(LanguageModel* inLM) - : m_LM(inLM), m_cursorIndex(0) {} +inline BlockReadingBuilder::BlockReadingBuilder(LanguageModel* lm) + : m_LM(lm), m_cursorIndex(0) {} inline void BlockReadingBuilder::clear() { m_cursorIndex = 0; @@ -88,14 +88,13 @@ inline size_t BlockReadingBuilder::length() const { return m_readings.size(); } inline size_t BlockReadingBuilder::cursorIndex() const { return m_cursorIndex; } -inline void BlockReadingBuilder::setCursorIndex(size_t inNewIndex) { - m_cursorIndex = - inNewIndex > m_readings.size() ? m_readings.size() : inNewIndex; +inline void BlockReadingBuilder::setCursorIndex(size_t newIndex) { + m_cursorIndex = newIndex > m_readings.size() ? m_readings.size() : newIndex; } inline void BlockReadingBuilder::insertReadingAtCursor( - const std::string& inReading) { - m_readings.insert(m_readings.begin() + m_cursorIndex, inReading); + const std::string& reading) { + m_readings.insert(m_readings.begin() + m_cursorIndex, reading); m_grid.expandGridByOneAtLocation(m_cursorIndex); build(); diff --git a/Source/Engine/Gramambular/Grid.h b/Source/Engine/Gramambular/Grid.h index eb42659a..2653074a 100644 --- a/Source/Engine/Gramambular/Grid.h +++ b/Source/Engine/Gramambular/Grid.h @@ -39,18 +39,17 @@ namespace Gramambular { class Grid { public: void clear(); - void insertNode(const Node& inNode, size_t inLocation, - size_t inSpanningLength); - bool hasNodeAtLocationSpanningLengthMatchingKey(size_t inLocation, - size_t inSpanningLength, - const std::string& inKey); + void insertNode(const Node& node, size_t location, size_t spanningLength); + bool hasNodeAtLocationSpanningLengthMatchingKey(size_t location, + size_t spanningLength, + const std::string& key); - void expandGridByOneAtLocation(size_t inLocation); - void shrinkGridByOneAtLocation(size_t inLocation); + void expandGridByOneAtLocation(size_t location); + void shrinkGridByOneAtLocation(size_t location); size_t width() const; - std::vector nodesEndingAt(size_t inLocation); - std::vector nodesCrossingOrEndingAt(size_t inLocation); + std::vector nodesEndingAt(size_t location); + std::vector nodesCrossingOrEndingAt(size_t location); // "Freeze" the node with the unigram that represents the selected candidate // value. After this, the node that contains the unigram will always be @@ -76,72 +75,72 @@ class Grid { inline void Grid::clear() { m_spans.clear(); } -inline void Grid::insertNode(const Node& inNode, size_t inLocation, - size_t inSpanningLength) { - if (inLocation >= m_spans.size()) { - size_t diff = inLocation - m_spans.size() + 1; +inline void Grid::insertNode(const Node& node, size_t location, + size_t spanningLength) { + if (location >= m_spans.size()) { + size_t diff = location - m_spans.size() + 1; for (size_t i = 0; i < diff; i++) { m_spans.push_back(Span()); } } - m_spans[inLocation].insertNodeOfLength(inNode, inSpanningLength); + m_spans[location].insertNodeOfLength(node, spanningLength); } inline bool Grid::hasNodeAtLocationSpanningLengthMatchingKey( - size_t inLocation, size_t inSpanningLength, const std::string& inKey) { - if (inLocation > m_spans.size()) { + size_t location, size_t spanningLength, const std::string& key) { + if (location > m_spans.size()) { return false; } - const Node* n = m_spans[inLocation].nodeOfLength(inSpanningLength); + const Node* n = m_spans[location].nodeOfLength(spanningLength); if (!n) { return false; } - return inKey == n->key(); + return key == n->key(); } -inline void Grid::expandGridByOneAtLocation(size_t inLocation) { - if (!inLocation || inLocation == m_spans.size()) { - m_spans.insert(m_spans.begin() + inLocation, Span()); +inline void Grid::expandGridByOneAtLocation(size_t location) { + if (!location || location == m_spans.size()) { + m_spans.insert(m_spans.begin() + location, Span()); } else { - m_spans.insert(m_spans.begin() + inLocation, Span()); - for (size_t i = 0; i < inLocation; i++) { + m_spans.insert(m_spans.begin() + location, Span()); + for (size_t i = 0; i < location; i++) { // zaps overlapping spans - m_spans[i].removeNodeOfLengthGreaterThan(inLocation - i); + m_spans[i].removeNodeOfLengthGreaterThan(location - i); } } } -inline void Grid::shrinkGridByOneAtLocation(size_t inLocation) { - if (inLocation >= m_spans.size()) { +inline void Grid::shrinkGridByOneAtLocation(size_t location) { + if (location >= m_spans.size()) { return; } - m_spans.erase(m_spans.begin() + inLocation); - for (size_t i = 0; i < inLocation; i++) { + m_spans.erase(m_spans.begin() + location); + for (size_t i = 0; i < location; i++) { // zaps overlapping spans - m_spans[i].removeNodeOfLengthGreaterThan(inLocation - i); + m_spans[i].removeNodeOfLengthGreaterThan(location - i); } } inline size_t Grid::width() const { return m_spans.size(); } -inline std::vector Grid::nodesEndingAt(size_t inLocation) { +inline std::vector Grid::nodesEndingAt(size_t location) { std::vector result; - if (m_spans.size() && inLocation <= m_spans.size()) { - for (size_t i = 0; i < inLocation; i++) { + if (m_spans.size() && location <= m_spans.size()) { + for (size_t i = 0; i < location; i++) { Span& span = m_spans[i]; - if (i + span.maximumLength() >= inLocation) { - Node* np = span.nodeOfLength(inLocation - i); + if (i + span.maximumLength() >= location) { + Node* np = span.nodeOfLength(location - i); if (np) { NodeAnchor na; na.node = np; na.location = i; - na.spanningLength = inLocation - i; + na.spanningLength = location - i; result.push_back(na); } @@ -152,17 +151,16 @@ inline std::vector Grid::nodesEndingAt(size_t inLocation) { return result; } -inline std::vector Grid::nodesCrossingOrEndingAt( - size_t inLocation) { +inline std::vector Grid::nodesCrossingOrEndingAt(size_t location) { std::vector result; - if (m_spans.size() && inLocation <= m_spans.size()) { - for (size_t i = 0; i < inLocation; i++) { + if (m_spans.size() && location <= m_spans.size()) { + for (size_t i = 0; i < location; i++) { Span& span = m_spans[i]; - if (i + span.maximumLength() >= inLocation) { + if (i + span.maximumLength() >= location) { for (size_t j = 1, m = span.maximumLength(); j <= m; j++) { - if (i + j < inLocation) { + if (i + j < location) { continue; } @@ -171,7 +169,7 @@ inline std::vector Grid::nodesCrossingOrEndingAt( NodeAnchor na; na.node = np; na.location = i; - na.spanningLength = inLocation - i; + na.spanningLength = location - i; result.push_back(na); } diff --git a/Source/Engine/Gramambular/KeyValuePair.h b/Source/Engine/Gramambular/KeyValuePair.h index 5c4f6b61..1059dfdc 100644 --- a/Source/Engine/Gramambular/KeyValuePair.h +++ b/Source/Engine/Gramambular/KeyValuePair.h @@ -39,25 +39,25 @@ class KeyValuePair { std::string key; std::string value; - bool operator==(const KeyValuePair& inAnother) const; - bool operator<(const KeyValuePair& inAnother) const; + bool operator==(const KeyValuePair& another) const; + bool operator<(const KeyValuePair& another) const; }; -inline std::ostream& operator<<(std::ostream& inStream, - const KeyValuePair& inPair) { - inStream << "(" << inPair.key << "," << inPair.value << ")"; - return inStream; +inline std::ostream& operator<<(std::ostream& stream, + const KeyValuePair& pair) { + stream << "(" << pair.key << "," << pair.value << ")"; + return stream; } -inline bool KeyValuePair::operator==(const KeyValuePair& inAnother) const { - return key == inAnother.key && value == inAnother.value; +inline bool KeyValuePair::operator==(const KeyValuePair& another) const { + return key == another.key && value == another.value; } -inline bool KeyValuePair::operator<(const KeyValuePair& inAnother) const { - if (key < inAnother.key) { +inline bool KeyValuePair::operator<(const KeyValuePair& another) const { + if (key < another.key) { return true; - } else if (key == inAnother.key) { - return value < inAnother.value; + } else if (key == another.key) { + return value < another.value; } return false; } diff --git a/Source/Engine/Gramambular/Node.h b/Source/Engine/Gramambular/Node.h index fe4690d9..a442c77f 100644 --- a/Source/Engine/Gramambular/Node.h +++ b/Source/Engine/Gramambular/Node.h @@ -39,15 +39,15 @@ namespace Gramambular { class Node { public: Node(); - Node(const std::string& inKey, const std::vector& inUnigrams, - const std::vector& inBigrams); + Node(const std::string& key, const std::vector& unigrams, + const std::vector& bigrams); void primeNodeWithPreceedingKeyValues( - const std::vector& inKeyValues); + const std::vector& keyValues); bool isCandidateFixed() const; const std::vector& candidates() const; - void selectCandidateAtIndex(size_t inIndex = 0, bool inFix = true); + void selectCandidateAtIndex(size_t index = 0, bool fix = true); void resetCandidate(); void selectFloatingCandidateAtIndex(size_t index, double score); @@ -71,25 +71,24 @@ class Node { bool m_candidateFixed; size_t m_selectedUnigramIndex; - friend std::ostream& operator<<(std::ostream& inStream, const Node& inNode); + friend std::ostream& operator<<(std::ostream& stream, const Node& node); }; -inline std::ostream& operator<<(std::ostream& inStream, const Node& inNode) { - inStream << "(node,key:" << inNode.m_key - << ",fixed:" << (inNode.m_candidateFixed ? "true" : "false") - << ",selected:" << inNode.m_selectedUnigramIndex << "," - << inNode.m_unigrams << ")"; - return inStream; +inline std::ostream& operator<<(std::ostream& stream, const Node& node) { + stream << "(node,key:" << node.m_key + << ",fixed:" << (node.m_candidateFixed ? "true" : "false") + << ",selected:" << node.m_selectedUnigramIndex << "," + << node.m_unigrams << ")"; + return stream; } inline Node::Node() : m_candidateFixed(false), m_selectedUnigramIndex(0), m_score(0.0) {} -inline Node::Node(const std::string& inKey, - const std::vector& inUnigrams, - const std::vector& inBigrams) - : m_key(inKey), - m_unigrams(inUnigrams), +inline Node::Node(const std::string& key, const std::vector& unigrams, + const std::vector& bigrams) + : m_key(key), + m_unigrams(unigrams), m_candidateFixed(false), m_selectedUnigramIndex(0), m_score(0.0) { @@ -108,20 +107,20 @@ inline Node::Node(const std::string& inKey, m_candidates.push_back((*ui).keyValue); } - for (std::vector::const_iterator bi = inBigrams.begin(); - bi != inBigrams.end(); ++bi) { + for (std::vector::const_iterator bi = bigrams.begin(); + bi != bigrams.end(); ++bi) { m_preceedingGramBigramMap[(*bi).preceedingKeyValue].push_back(*bi); } } inline void Node::primeNodeWithPreceedingKeyValues( - const std::vector& inKeyValues) { + const std::vector& keyValues) { size_t newIndex = m_selectedUnigramIndex; double max = m_score; if (!isCandidateFixed()) { - for (std::vector::const_iterator kvi = inKeyValues.begin(); - kvi != inKeyValues.end(); ++kvi) { + for (std::vector::const_iterator kvi = keyValues.begin(); + kvi != keyValues.end(); ++kvi) { std::map >::const_iterator f = m_preceedingGramBigramMap.find(*kvi); if (f != m_preceedingGramBigramMap.end()) { @@ -158,14 +157,14 @@ inline const std::vector& Node::candidates() const { return m_candidates; } -inline void Node::selectCandidateAtIndex(size_t inIndex, bool inFix) { - if (inIndex >= m_unigrams.size()) { +inline void Node::selectCandidateAtIndex(size_t index, bool fix) { + if (index >= m_unigrams.size()) { m_selectedUnigramIndex = 0; } else { - m_selectedUnigramIndex = inIndex; + m_selectedUnigramIndex = index; } - m_candidateFixed = inFix; + m_candidateFixed = fix; m_score = 99; } diff --git a/Source/Engine/Gramambular/NodeAnchor.h b/Source/Engine/Gramambular/NodeAnchor.h index 2ddef073..f2b4dfc8 100644 --- a/Source/Engine/Gramambular/NodeAnchor.h +++ b/Source/Engine/Gramambular/NodeAnchor.h @@ -32,42 +32,37 @@ namespace Formosa { namespace Gramambular { -class NodeAnchor { - public: - NodeAnchor(); - const Node* node; - size_t location; - size_t spanningLength; - double accumulatedScore; + +struct NodeAnchor { + const Node* node = nullptr; + size_t location = 0; + size_t spanningLength = 0; + double accumulatedScore = 0.0; }; -inline NodeAnchor::NodeAnchor() - : node(0), location(0), spanningLength(0), accumulatedScore(0.0) {} - -inline std::ostream& operator<<(std::ostream& inStream, - const NodeAnchor& inAnchor) { - inStream << "{@(" << inAnchor.location << "," << inAnchor.spanningLength - << "),"; - if (inAnchor.node) { - inStream << *(inAnchor.node); +inline std::ostream& operator<<(std::ostream& stream, + const NodeAnchor& anchor) { + stream << "{@(" << anchor.location << "," << anchor.spanningLength << "),"; + if (anchor.node) { + stream << *(anchor.node); } else { - inStream << "null"; + stream << "null"; } - inStream << "}"; - return inStream; + stream << "}"; + return stream; } -inline std::ostream& operator<<(std::ostream& inStream, - const std::vector& inAnchor) { - for (std::vector::const_iterator i = inAnchor.begin(); - i != inAnchor.end(); ++i) { - inStream << *i; - if (i + 1 != inAnchor.end()) { - inStream << "<-"; +inline std::ostream& operator<<(std::ostream& stream, + const std::vector& anchor) { + for (std::vector::const_iterator i = anchor.begin(); + i != anchor.end(); ++i) { + stream << *i; + if (i + 1 != anchor.end()) { + stream << "<-"; } } - return inStream; + return stream; } } // namespace Gramambular } // namespace Formosa diff --git a/Source/Engine/Gramambular/Span.h b/Source/Engine/Gramambular/Span.h index c733886b..795c2a48 100644 --- a/Source/Engine/Gramambular/Span.h +++ b/Source/Engine/Gramambular/Span.h @@ -38,36 +38,32 @@ namespace Formosa { namespace Gramambular { class Span { public: - Span(); - void clear(); - void insertNodeOfLength(const Node& inNode, size_t inLength); - void removeNodeOfLengthGreaterThan(size_t inLength); + void insertNodeOfLength(const Node& node, size_t length); + void removeNodeOfLengthGreaterThan(size_t length); - Node* nodeOfLength(size_t inLength); + Node* nodeOfLength(size_t length); size_t maximumLength() const; protected: std::map m_lengthNodeMap; - size_t m_maximumLength; + size_t m_maximumLength = 0; }; -inline Span::Span() : m_maximumLength(0) {} - inline void Span::clear() { m_lengthNodeMap.clear(); m_maximumLength = 0; } -inline void Span::insertNodeOfLength(const Node& inNode, size_t inLength) { - m_lengthNodeMap[inLength] = inNode; - if (inLength > m_maximumLength) { - m_maximumLength = inLength; +inline void Span::insertNodeOfLength(const Node& node, size_t length) { + m_lengthNodeMap[length] = node; + if (length > m_maximumLength) { + m_maximumLength = length; } } -inline void Span::removeNodeOfLengthGreaterThan(size_t inLength) { - if (inLength > m_maximumLength) { +inline void Span::removeNodeOfLengthGreaterThan(size_t length) { + if (length > m_maximumLength) { return; } @@ -76,7 +72,7 @@ inline void Span::removeNodeOfLengthGreaterThan(size_t inLength) { for (std::map::iterator i = m_lengthNodeMap.begin(), e = m_lengthNodeMap.end(); i != e; ++i) { - if ((*i).first > inLength) { + if ((*i).first > length) { removeSet.insert((*i).first); } else { if ((*i).first > max) { @@ -93,8 +89,8 @@ inline void Span::removeNodeOfLengthGreaterThan(size_t inLength) { m_maximumLength = max; } -inline Node* Span::nodeOfLength(size_t inLength) { - std::map::iterator f = m_lengthNodeMap.find(inLength); +inline Node* Span::nodeOfLength(size_t length) { + std::map::iterator f = m_lengthNodeMap.find(length); return f == m_lengthNodeMap.end() ? 0 : &(*f).second; } diff --git a/Source/Engine/Gramambular/Unigram.h b/Source/Engine/Gramambular/Unigram.h index c40322e7..df09cd0c 100644 --- a/Source/Engine/Gramambular/Unigram.h +++ b/Source/Engine/Gramambular/Unigram.h @@ -34,6 +34,7 @@ namespace Formosa { namespace Gramambular { + class Unigram { public: Unigram(); @@ -41,50 +42,50 @@ class Unigram { KeyValuePair keyValue; double score; - bool operator==(const Unigram& inAnother) const; - bool operator<(const Unigram& inAnother) const; + bool operator==(const Unigram& another) const; + bool operator<(const Unigram& another) const; static bool ScoreCompare(const Unigram& a, const Unigram& b); }; -inline std::ostream& operator<<(std::ostream& inStream, const Unigram& inGram) { - std::streamsize p = inStream.precision(); - inStream.precision(6); - inStream << "(" << inGram.keyValue << "," << inGram.score << ")"; - inStream.precision(p); - return inStream; +inline std::ostream& operator<<(std::ostream& stream, const Unigram& gram) { + std::streamsize p = stream.precision(); + stream.precision(6); + stream << "(" << gram.keyValue << "," << gram.score << ")"; + stream.precision(p); + return stream; } -inline std::ostream& operator<<(std::ostream& inStream, - const std::vector& inGrams) { - inStream << "[" << inGrams.size() << "]=>{"; +inline std::ostream& operator<<(std::ostream& stream, + const std::vector& grams) { + stream << "[" << grams.size() << "]=>{"; size_t index = 0; - for (std::vector::const_iterator gi = inGrams.begin(); - gi != inGrams.end(); ++gi, ++index) { - inStream << index << "=>"; - inStream << *gi; - if (gi + 1 != inGrams.end()) { - inStream << ","; + for (std::vector::const_iterator gi = grams.begin(); + gi != grams.end(); ++gi, ++index) { + stream << index << "=>"; + stream << *gi; + if (gi + 1 != grams.end()) { + stream << ","; } } - inStream << "}"; - return inStream; + stream << "}"; + return stream; } inline Unigram::Unigram() : score(0.0) {} -inline bool Unigram::operator==(const Unigram& inAnother) const { - return keyValue == inAnother.keyValue && score == inAnother.score; +inline bool Unigram::operator==(const Unigram& another) const { + return keyValue == another.keyValue && score == another.score; } -inline bool Unigram::operator<(const Unigram& inAnother) const { - if (keyValue < inAnother.keyValue) { +inline bool Unigram::operator<(const Unigram& another) const { + if (keyValue < another.keyValue) { return true; - } else if (keyValue == inAnother.keyValue) { - return score < inAnother.score; + } else if (keyValue == another.keyValue) { + return score < another.score; } return false; } diff --git a/Source/Engine/Gramambular/Walker.h b/Source/Engine/Gramambular/Walker.h index 3c383105..b35d2322 100644 --- a/Source/Engine/Gramambular/Walker.h +++ b/Source/Engine/Gramambular/Walker.h @@ -38,8 +38,8 @@ namespace Gramambular { class Walker { public: Walker(Grid* inGrid); - const std::vector reverseWalk(size_t inLocation, - double inAccumulatedScore = 0.0); + const std::vector reverseWalk(size_t location, + double accumulatedScore = 0.0); protected: Grid* m_grid; @@ -48,14 +48,14 @@ class Walker { inline Walker::Walker(Grid* inGrid) : m_grid(inGrid) {} inline const std::vector Walker::reverseWalk( - size_t inLocation, double inAccumulatedScore) { - if (!inLocation || inLocation > m_grid->width()) { + size_t location, double accumulatedScore) { + if (!location || location > m_grid->width()) { return std::vector(); } std::vector > paths; - std::vector nodes = m_grid->nodesEndingAt(inLocation); + std::vector nodes = m_grid->nodesEndingAt(location); for (std::vector::iterator ni = nodes.begin(); ni != nodes.end(); ++ni) { @@ -63,10 +63,10 @@ inline const std::vector Walker::reverseWalk( continue; } - (*ni).accumulatedScore = inAccumulatedScore + (*ni).node->score(); + (*ni).accumulatedScore = accumulatedScore + (*ni).node->score(); std::vector path = - reverseWalk(inLocation - (*ni).spanningLength, (*ni).accumulatedScore); + reverseWalk(location - (*ni).spanningLength, (*ni).accumulatedScore); path.insert(path.begin(), *ni); paths.push_back(path);