Add removing duplicate tokens to input_parser

src/keyboard_input/input_parser.cpp

@@ -225,7 +225,7 @@ std::vector<Token>
 }
 
 std::vector<Token>
-    removeDuplicateNewSequences( const std::vector<Token>& tokens )
+    removeDuplicateNewSequences( const std::vector<Token>& tokens ) noexcept
 {
     std::vector<Token> approvedTokens = {};
 
@@ -253,7 +253,48 @@ std::vector<Token>
     return approvedTokens;
 }
 
-std::vector<Token> removeIncorrectTokens( const std::vector<Token>& tokens )
+std::vector<Token>
+    removeTokenInSameSequence( const std::vector<Token>& tokens,
+                               const Token tokenToRemove ) noexcept
 {
-    return removeDuplicateNewSequences( tokens );
+    std::vector<Token> approvedTokens = {};
+
+    bool tokenInSequence = false;
+    for ( const auto& token : tokens )
+    {
+        if ( token == Token::TOKEN_NEW_SEQUENCE )
+        {
+            tokenInSequence = false;
+        }
+
+        if ( tokenInSequence && ( token == tokenToRemove ) )
+        {
+            continue;
+        }
+
+        if ( token == tokenToRemove )
+        {
+            tokenInSequence = true;
+        }
+        approvedTokens.push_back( token );
+    }
+    return approvedTokens;
+}
+
+std::vector<Token>
+    removeIncorrectTokens( const std::vector<Token>& tokens ) noexcept
+{
+    const auto spacesRemoved = removeDuplicateNewSequences( tokens );
+    const auto ctrlRemoved
+        = removeTokenInSameSequence( spacesRemoved, Token::MODIFIER_CTRL );
+    const auto altRemoved
+        = removeTokenInSameSequence( ctrlRemoved, Token::MODIFIER_ALT );
+    const auto shiftRemoved
+        = removeTokenInSameSequence( altRemoved, Token::MODIFIER_SHIFT );
+    const auto altgrRemoved
+        = removeTokenInSameSequence( shiftRemoved, Token::MODIFIER_ALTGR );
+    const auto superRemoved
+        = removeTokenInSameSequence( altgrRemoved, Token::MODIFIER_SUPER );
+
+    return superRemoved;
 }

src/keyboard_input/input_parser.h

@@ -90,4 +90,5 @@ enum class Token
 
 std::vector<Token>
     ParseKeyboardInputsToTokens( const std::string inputs ) noexcept;
-std::vector<Token> removeIncorrectTokens( const std::vector<Token>& tokens );
+std::vector<Token>
+    removeIncorrectTokens( const std::vector<Token>& tokens ) noexcept;

test/keyboard_input/tst_parsertest.cpp

@@ -38,6 +38,10 @@ private slots:
     void sixtyfourAsBenchmarked();
 
     void removeDuplicateSpaces();
+
+    void removeDuplicateModifiers();
+
+    void removeIncorrectTokensBenchmark();
 };
 
 const std::string alphabet = "abcdefghijklmnopqrstuvxyz";
@@ -393,6 +397,123 @@ void ParserTest::removeDuplicateSpaces()
     QCOMPARE( removeIncorrectTokens( e ), t );
 }
 
+void ParserTest::removeDuplicateModifiers()
+{
+    auto e = std::vector<Token>( { Token::KEY_a,
+                                   Token::MODIFIER_CTRL,
+                                   Token::KEY_a,
+                                   Token::MODIFIER_CTRL,
+                                   Token::TOKEN_NEW_SEQUENCE,
+                                   Token::MODIFIER_ALT,
+                                   Token::KEY_TAB,
+                                   Token::KEY_d } );
+    auto t = std::vector<Token>( { Token::KEY_a,
+                                   Token::MODIFIER_CTRL,
+                                   Token::KEY_a,
+                                   Token::TOKEN_NEW_SEQUENCE,
+                                   Token::MODIFIER_ALT,
+                                   Token::KEY_TAB,
+                                   Token::KEY_d } );
+
+    QCOMPARE( removeIncorrectTokens( e ), t );
+
+    e = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_a,
+                              Token::MODIFIER_ALT,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+    t = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_a,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+
+    QCOMPARE( removeIncorrectTokens( e ), t );
+
+    e = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_SHIFT,
+                              Token::KEY_a,
+                              Token::MODIFIER_SHIFT,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+    t = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_SHIFT,
+                              Token::KEY_a,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+
+    QCOMPARE( removeIncorrectTokens( e ), t );
+
+    e = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_ALTGR,
+                              Token::KEY_a,
+                              Token::MODIFIER_ALTGR,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+    t = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_ALTGR,
+                              Token::KEY_a,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+
+    QCOMPARE( removeIncorrectTokens( e ), t );
+
+    e = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_SUPER,
+                              Token::KEY_a,
+                              Token::MODIFIER_SUPER,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+    t = std::vector<Token>( { Token::KEY_a,
+                              Token::MODIFIER_SUPER,
+                              Token::KEY_a,
+                              Token::TOKEN_NEW_SEQUENCE,
+                              Token::MODIFIER_ALT,
+                              Token::KEY_TAB,
+                              Token::KEY_d } );
+
+    QCOMPARE( removeIncorrectTokens( e ), t );
+}
+
+void ParserTest::removeIncorrectTokensBenchmark()
+{
+    auto e = std::vector<Token>( 100, Token::MODIFIER_SHIFT );
+
+    e.at( 0 ) = Token::KEY_a;
+    e.at( 10 ) = Token::TOKEN_NEW_SEQUENCE;
+    e.at( 11 ) = Token::KEY_a;
+    e.at( 95 ) = Token::KEY_a;
+
+    auto t = std::vector<Token>( { Token::KEY_a,
+                                   Token::MODIFIER_SHIFT,
+                                   Token::TOKEN_NEW_SEQUENCE,
+                                   Token::KEY_a,
+                                   Token::MODIFIER_SHIFT,
+                                   Token::KEY_a } );
+
+    QCOMPARE( removeIncorrectTokens( e ), t );
+
+    QBENCHMARK
+    {
+        QCOMPARE( removeIncorrectTokens( e ), t );
+    }
+}
+
 QTEST_APPLESS_MAIN( ParserTest )
 
 #include "./release/tst_parsertest.moc"